renamed initialization functions of virtio devices to open instead of init.
[barrelfish] / usr / kaluga / driver_startup.c
1 #include <stdio.h>
2 #include <string.h>
3
4 #include <barrelfish/barrelfish.h>
5 #include <barrelfish/spawn_client.h>
6
7 #ifdef __arm__
8 #include <if/monitor_blocking_rpcclient_defs.h>
9 #endif
10
11 #include "kaluga.h"
12
13 extern char **environ;
14
15 #ifdef __x86__
16 errval_t default_start_function(coreid_t where, struct module_info* mi,
17         char* record)
18 {
19     assert(mi != NULL);
20     errval_t err = SYS_ERR_OK;
21 /*
22  *  XXX: there may be more device using this driver, so starting it a second time
23  *       may be needed.
24  */
25     if (is_started(mi) && strcmp("xeon_phi  ",mi->binary)) {
26         return KALUGA_ERR_DRIVER_ALREADY_STARTED;
27     }
28
29     if (!is_auto_driver(mi)) {
30         return KALUGA_ERR_DRIVER_NOT_AUTO;
31     }
32
33     // Construct additional command line arguments containing pci-id.
34     // We need one extra entry for the new argument.
35     uint64_t vendor_id, device_id, bus, dev, fun;
36     char **argv = mi->argv;
37     bool cleanup = false;
38
39     err = oct_read(record,
40                    "_ { bus: %d, device: %d, function: %d, vendor: %d, device_id: %d }",
41                    &bus, &dev, &fun, &vendor_id, &device_id);
42
43     if (err_is_ok(err)) {
44         // We assume that we're starting a device if the query above succeeds
45         // and therefore append the pci vendor and device id to the argument
46         // list.
47         argv = malloc((mi->argc+1) * sizeof(char *));
48         memcpy(argv, mi->argv, mi->argc * sizeof(char *));
49         char *pci_id  = malloc(26);
50         // Make sure pci vendor and device id fit into our argument
51         assert(vendor_id < 0x9999 && device_id < 0x9999);
52         snprintf(pci_id, 26, "%04"PRIx64":%04"PRIx64":%04"PRIx64":%04"
53                  PRIx64":%04"PRIx64, vendor_id, device_id, bus, dev, fun);
54
55         argv[mi->argc] = pci_id;
56         argv[mi->argc+1] = NULL;
57         cleanup = true;
58     }
59     err = spawn_program(where, mi->path, argv,
60             environ, 0, &mi->did);
61
62     if (err_is_fail(err)) {
63         DEBUG_ERR(err, "Spawning %s failed.", mi->path);
64     }
65     if (cleanup) {
66         // alloc'd string is the last of our array
67         free(argv[mi->argc]);
68         free(argv);
69     }
70
71     return err;
72 }
73 #endif
74
75 errval_t start_networking(coreid_t core, struct module_info* driver,
76         char* record)
77 {
78     assert(driver != NULL);
79     errval_t err = SYS_ERR_OK;
80
81     if (is_started(driver)) {
82         return KALUGA_ERR_DRIVER_ALREADY_STARTED;
83     }
84
85     if (!is_auto_driver(driver)) {
86         return KALUGA_ERR_DRIVER_NOT_AUTO;
87     }
88
89     struct module_info* netd = find_module("netd");
90     if (netd == NULL || !is_auto_driver(netd)) {
91         KALUGA_DEBUG("netd not found or not declared as auto.");
92         return KALUGA_ERR_DRIVER_NOT_AUTO;
93     }
94
95     struct module_info* ngd_mng = find_module("NGD_mng");
96     if (ngd_mng == NULL || !is_auto_driver(ngd_mng)) {
97         KALUGA_DEBUG("NGD_mng not found or not declared as auto.");
98         return KALUGA_ERR_DRIVER_NOT_AUTO;
99     }
100
101     err = spawn_program(core, driver->path, driver->argv + 1, environ, 0,
102             &driver->did);
103     if (err_is_fail(err)) {
104         DEBUG_ERR(err, "Spawning %s failed.", driver->path);
105         return err;
106     }
107
108     // XXX: Manually add cardname (overwrite first (auto) argument)
109     // +Weird convention, e1000n binary but cardname=e1000
110     char* cardname =
111             strcmp(driver->binary, "e1000n") == 0 ? "e1000" : driver->binary;
112
113     size_t name_len = strlen("cardname=") + strlen(cardname) + 1;
114     char* card_argument = malloc(name_len);
115     sprintf(card_argument, "cardname=%s", cardname);
116     printf("############# starting network with arguments %s\n", card_argument);
117
118     // Spawn netd and ngd_mng
119     netd->argv[0] = card_argument;
120     err = spawn_program(core, netd->path, netd->argv, environ, 0, &netd->did);
121
122     ngd_mng->argv[0] = card_argument;
123     err = spawn_program(core, ngd_mng->path, ngd_mng->argv, environ, 0,
124             &ngd_mng->did);
125
126     free(card_argument);
127     return err;
128 }
129
130 /* errval_t start_usb_manager(void) */
131 /* { */
132
133 /*     struct module_info* driver = find_module("usb_manager"); */
134 /*     if (driver == NULL || !is_auto_driver(driver)) { */
135 /*         KALUGA_DEBUG("NGD_mng not found or not declared as auto."); */
136 /*         return KALUGA_ERR_DRIVER_NOT_AUTO; */
137 /*     } */
138
139 /*     debug_printf("doing pandaboard related setup...\n"); */
140 /*     errval_t err; */
141
142 /*     struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client(); */
143 /*     assert(cl != NULL); */
144
145 /*     // Request I/O Cap */
146 /*     struct capref requested_caps; */
147 /*     errval_t error_code; */
148
149 /*     err = cl->vtbl.get_io_cap(cl, &requested_caps, &error_code); */
150 /*     assert(err_is_ok(err) && err_is_ok(error_code)); */
151
152 /*     // Copy into correct slot */
153
154 /*     struct capref device_range_cap = NULL_CAP; */
155
156 /*     err = slot_alloc(&device_range_cap); */
157 /*     if (err_is_fail(err)) { */
158 /*         printf("slot alloc failed. Step 1\n"); */
159 /*         return (err); */
160 /*     } */
161 /*     struct capref tiler_cap = NULL_CAP; */
162
163 /*     err = slot_alloc(&tiler_cap); */
164 /*     if (err_is_fail(err)) { */
165 /*         DEBUG_ERR(err, "slot_alloc failed. Step 1\n"); */
166 /*         return (err); */
167 /*     } */
168
169 /*     err = cap_retype(device_range_cap, requested_caps, ObjType_DevFrame, 29); */
170
171 /*     struct capref l3_ocm_ram = NULL_CAP; */
172
173 /*     err = slot_alloc(&l3_ocm_ram); */
174 /*     if (err_is_fail(err)) { */
175 /*         DEBUG_ERR(err, "slot_alloc failed. Step 2\n"); */
176 /*         return (err); */
177 /*     } */
178
179 /*     err = cap_retype(l3_ocm_ram, device_range_cap, ObjType_DevFrame, 26); */
180 /*     if (err_is_fail(err)) { */
181 /*         DEBUG_ERR(err, "failed to retype the dev cap. Step 3\n"); */
182 /*         return (err); */
183 /*     } */
184
185 /*     struct capref l3_config_registers_cap; */
186 /*     err = slot_alloc(&l3_config_registers_cap); */
187 /*     if (err_is_fail(err)) { */
188 /*         DEBUG_ERR(err, "slot alloc failed. Step 4\n"); */
189 /*         return (err); */
190 /*     } */
191
192 /*     struct capref l4_domains_cap; */
193 /*     err = slot_alloc(&l4_domains_cap); */
194 /*     if (err_is_fail(err)) { */
195 /*         DEBUG_ERR(err, "slot_alloc failed. Step 5\n"); */
196 /*         return (err); */
197 /*     } */
198
199 /*     struct capref emif_registers_cap; */
200 /*     err = slot_alloc(&emif_registers_cap); */
201 /*     if (err_is_fail(err)) { */
202 /*         DEBUG_ERR(err, "slot_alloc failed. Step 6\n"); */
203 /*         return (err); */
204 /*     } */
205
206 /*     struct capref gpmc_iss_cap; */
207 /*     err = slot_alloc(&gpmc_iss_cap); */
208 /*     if (err_is_fail(err)) { */
209 /*         DEBUG_ERR(err, "slot_alloc failed. Step 7\n"); */
210 /*         return (err); */
211 /*     } */
212
213 /*     struct capref l3_emu_m3_sgx_cap; */
214 /*     err = slot_alloc(&l3_emu_m3_sgx_cap); */
215 /*     if (err_is_fail(err)) { */
216 /*         DEBUG_ERR(err, "slot_alloc failed. Step 8\n"); */
217 /*         return (err); */
218 /*     } */
219
220 /*     struct capref display_iva_cap; */
221 /*     err = slot_alloc(&display_iva_cap); */
222 /*     if (err_is_fail(err)) { */
223 /*         DEBUG_ERR(err, "slot_alloc failed. Step 9\n"); */
224 /*         return (err); */
225 /*     } */
226 /*     struct capref tmp_cap = display_iva_cap; */
227 /*     tmp_cap.slot++; */
228 /*     cap_delete(tmp_cap); */
229
230 /*     struct capref l4_PER_domain_cap; */
231 /*     err = slot_alloc(&l4_PER_domain_cap); */
232 /*     if (err_is_fail(err)) { */
233 /*         DEBUG_ERR(err, "slot_alloc failed. Step 12\n"); */
234 /*         return (err); */
235 /*     } */
236
237 /*     struct capref l4_ABE_domain_cap; */
238 /*     err = slot_alloc(&l4_ABE_domain_cap); */
239 /*     if (err_is_fail(err)) { */
240 /*         DEBUG_ERR(err, "slot_alloc failed. Step 11\n"); */
241 /*         return (err); */
242 /*     } */
243
244 /*     struct capref l4_CFG_domain_cap; */
245 /*     err = slot_alloc(&l4_CFG_domain_cap); */
246 /*     if (err_is_fail(err)) { */
247 /*         DEBUG_ERR(err, "slot_alloc failed. Step 12\n"); */
248 /*         return (err); */
249 /*     } */
250
251 /*     err = cap_retype(l4_PER_domain_cap, l4_domains_cap, ObjType_DevFrame, 24); */
252 /*     if (err_is_fail(err)) { */
253 /*         DEBUG_ERR(err, "failed to retype the cap. Step 13\n"); */
254 /*         return (err); */
255 /*     } */
256 /*     tmp_cap = l4_CFG_domain_cap; */
257 /*     tmp_cap.slot++; */
258 /*     cap_delete(tmp_cap); */
259
260 /*     struct frame_identity frameid;  // = {        0,        0    }; */
261
262 /*     err = invoke_frame_identify(l4_CFG_domain_cap, &frameid); */
263 /*     if (err_is_fail(err)) { */
264 /*         DEBUG_ERR(err, "could not identify the frame. Step 14\n"); */
265 /*     } */
266
267 /*     // get the 32 bit */
268 /*     uint32_t last = (uint32_t) (0xFFFFFFFF & (frameid.base)); */
269 /*     uint32_t size2 = frameid.bits; */
270
271 /*     /\* the L4 CFG domain cap must have address 0x4A000000 *\/ */
272 /*     assert(last == 0x4a000000); */
273
274 /*     /\* the size of the L4 CFG domain is 16k *\/ */
275 /*     assert(((1 << size2) / 1024) == (16 * 1024)); */
276
277 /* #define USB_SUBSYSTEM_L4_OFFSET 0x00062000 */
278 /* //#define USB_OHCI_OFFSET         (0x000A9000-USB_SUBSYSTEM_L4_OFFSET) */
279 /* #define USB_OHCI_OFFSET         0x00002800 */
280 /* #define USB_EHCI_OFFSET         0x00002C00 */
281
282 /* #define USB_ARM_EHCI_IRQ 109 */
283
284 /*     uint32_t tmp = (uint32_t) USB_EHCI_OFFSET + USB_SUBSYSTEM_L4_OFFSET; */
285
286 /*     char buf[255]; */
287 /*     uint8_t offset = 0; */
288 /*     driver->cmdargs = buf; */
289 /*     driver->argc = 3; */
290 /*     driver->argv[0] = driver->cmdargs+0; */
291
292 /*     snprintf(buf+offset, 255-offset, "ehci\0"); */
293 /*     offset += strlen(driver->argv[0])+1; */
294 /*     driver->argv[1] = driver->cmdargs+offset; */
295 /*     snprintf(buf+offset, 255-offset, "%u\0", tmp); */
296 /*     offset += strlen(driver->argv[1])+1; */
297 /*             driver->argv[2] = driver->cmdargs+offset; */
298 /*     snprintf(buf+offset, 255-offset, "%u\0", USB_ARM_EHCI_IRQ); */
299
300 /*     err = SYS_ERR_OK; */
301 /*     coreid_t core = 0; */
302
303 /*     if (is_started(driver)) { */
304 /*         debug_printf("driver is already started..."); */
305 /*         return KALUGA_ERR_DRIVER_ALREADY_STARTED; */
306 /*     } */
307
308
309 /*     err = spawn_program_with_caps(core, driver->path, driver->argv, environ, */
310 /*             NULL_CAP, l4_CFG_domain_cap, 0, &driver->did); */
311 /*     if (err_is_fail(err)) { */
312 /*         DEBUG_ERR(err, "Spawning %s failed.", driver->path); */
313 /*         return err; */
314 /*     } */
315
316 /*     return err; */
317 /* } */