fe794cdecb72313b7267e55a497d9b70e5845fbe
[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
60     printf("Default Q %d Interrupt %d \n", default_q, !poll);
61
62     err = e10k_queue_create((struct e10k_queue**)retqueue, interrupt,
63                             false /*virtual functions*/,
64                             !poll, /* user interrupts*/
65                             default_q);
66     *queueid = e10k_queue_get_id((struct e10k_queue*)*retqueue);
67     assert(retqueue != NULL);
68     return err;
69 }
70
71 static errval_t create_sfn5122f_queue(const char* cardname, inthandler_t interrupt, uint64_t *queueid,
72                                       bool default_q, bool poll, struct devq **retqueue)
73 {
74     errval_t err;
75     err = sfn5122f_queue_create((struct sfn5122f_queue**)retqueue, interrupt,
76                                 false /*userlevel network feature*/,
77                                 !poll /* user interrupts*/,
78                                 default_q);
79     *queueid = sfn5122f_queue_get_id((struct sfn5122f_queue*)*retqueue);
80     return err;
81 }
82
83
84 typedef errval_t (*queue_create_fn)(const char*, inthandler_t, uint64_t*, bool, bool, struct devq **);
85 struct networking_card
86 {
87     char *cardname;
88     queue_create_fn createfn;
89 } networking_cards [] = {
90     { "loopback", create_loopback_queue},
91     { "driver", create_driver_queue},
92     { "e1000", create_e1000_queue},
93     { "e10k", create_e10k_queue},
94     { "sfn5122f", create_sfn5122f_queue},
95     { NULL, NULL}
96 };
97
98
99 /**
100  * @brief creates a queue to the given card and the queueid
101  *
102  * @param interrupt interrupt handler 
103  * @param cardname  network card to create the queue for
104  * @param queueid   queueid of the network card
105  * @param default_q get the default queue (most of the time queue 0)
106  * @param poll      Is the queue polled or are interrupts used
107  * @param retqueue  returns the pointer to the queue
108  *
109  * @return SYS_ERR_OK on success, errval on failure
110  */
111 errval_t net_queue_internal_create(inthandler_t interrupt, const char *cardname,
112                                    uint64_t* queueid, bool default_q, bool poll, struct devq **retqueue)
113 {
114     struct networking_card *nc = networking_cards;
115     while(nc->cardname != NULL) {
116         if (strncmp(cardname, nc->cardname, strlen(nc->cardname)) == 0) {
117             return nc->createfn(cardname, interrupt, queueid, default_q, 
118                                 poll, retqueue);
119         }
120         nc++;
121     }
122
123     debug_printf("net: ERROR unknown queue. card='%s', queueid=%" PRIu64 "\n",
124                   cardname, *queueid);
125
126     return -1;
127 }
128
129
130 /**
131  * @brief creates a queue to the given card and the queueid
132  *
133  * @param interrupt interrupt handler 
134  * @param cardname  network card to create the queue for
135  * @param queueid   queueid of the network card
136  * @param poll      Is the queue polled or are interrupts used
137  * @param retqueue  returns the pointer to the queue
138  *
139  * @return SYS_ERR_OK on success, errval on failure
140  */
141 errval_t net_queue_create(inthandler_t interrupt, const char *cardname,
142                           uint64_t* queueid, bool poll, struct devq **retqueue)
143 {
144     return net_queue_internal_create(interrupt, cardname, queueid, false, poll, retqueue);
145 }