Bugfixes Xeon Phi Driver startup - removed check for boot info - added initialization...
[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
60     if (is_started(mi) && !strcmp("xeon_phi",mi->binary)) {
61         where !=20;
62     }
63
64     err = spawn_program(where, mi->path, argv,
65                     environ, 0, &mi->did);
66
67     if (err_is_fail(err)) {
68         DEBUG_ERR(err, "Spawning %s failed.", mi->path);
69     }
70     if (cleanup) {
71         // alloc'd string is the last of our array
72         free(argv[mi->argc]);
73         free(argv);
74     }
75
76     return err;
77 }
78 #endif
79
80 errval_t start_networking(coreid_t core,
81                           struct module_info* driver,
82                           char* record)
83 {
84     assert(driver != NULL);
85     errval_t err = SYS_ERR_OK;
86
87     if (is_started(driver)) {
88         return KALUGA_ERR_DRIVER_ALREADY_STARTED;
89     }
90
91     if (!is_auto_driver(driver)) {
92         return KALUGA_ERR_DRIVER_NOT_AUTO;
93     }
94
95     struct module_info* netd = find_module("netd");
96     if (netd == NULL || !is_auto_driver(netd)) {
97         KALUGA_DEBUG("netd not found or not declared as auto.");
98         return KALUGA_ERR_DRIVER_NOT_AUTO;
99     }
100
101     struct module_info* ngd_mng = find_module("NGD_mng");
102     if (ngd_mng == NULL || !is_auto_driver(ngd_mng)) {
103         KALUGA_DEBUG("NGD_mng not found or not declared as auto.");
104         return KALUGA_ERR_DRIVER_NOT_AUTO;
105     }
106
107     err = spawn_program(core,
108                         driver->path,
109                         driver->argv + 1,
110                         environ,
111                         0,
112                         &driver->did);
113     if (err_is_fail(err)) {
114         DEBUG_ERR(err, "Spawning %s failed.", driver->path);
115         return err;
116     }
117
118     // XXX: Manually add cardname (overwrite first (auto) argument)
119     // +Weird convention, e1000n binary but cardname=e1000
120     char* cardname =
121                     strcmp(driver->binary, "e1000n") == 0 ? "e1000" : driver->binary;
122
123     size_t name_len = strlen("cardname=") + strlen(cardname) + 1;
124     char* card_argument = malloc(name_len);
125     sprintf(card_argument, "cardname=%s", cardname);
126     printf("############# starting network with arguments %s\n", card_argument);
127
128     // Spawn netd and ngd_mng
129     netd->argv[0] = card_argument;
130     err = spawn_program(core, netd->path, netd->argv, environ, 0, &netd->did);
131
132     ngd_mng->argv[0] = card_argument;
133     err = spawn_program(core,
134                         ngd_mng->path,
135                         ngd_mng->argv,
136                         environ,
137                         0,
138                         &ngd_mng->did);
139
140     free(card_argument);
141     return err;
142 }
143
144 /* errval_t start_usb_manager(void) */
145 /* { */
146
147 /*     struct module_info* driver = find_module("usb_manager"); */
148 /*     if (driver == NULL || !is_auto_driver(driver)) { */
149 /*         KALUGA_DEBUG("NGD_mng not found or not declared as auto."); */
150 /*         return KALUGA_ERR_DRIVER_NOT_AUTO; */
151 /*     } */
152
153 /*     debug_printf("doing pandaboard related setup...\n"); */
154 /*     errval_t err; */
155
156 /*     struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client(); */
157 /*     assert(cl != NULL); */
158
159 /*     // Request I/O Cap */
160 /*     struct capref requested_caps; */
161 /*     errval_t error_code; */
162
163 /*     err = cl->vtbl.get_io_cap(cl, &requested_caps, &error_code); */
164 /*     assert(err_is_ok(err) && err_is_ok(error_code)); */
165
166 /*     // Copy into correct slot */
167
168 /*     struct capref device_range_cap = NULL_CAP; */
169
170 /*     err = slot_alloc(&device_range_cap); */
171 /*     if (err_is_fail(err)) { */
172 /*         printf("slot alloc failed. Step 1\n"); */
173 /*         return (err); */
174 /*     } */
175 /*     struct capref tiler_cap = NULL_CAP; */
176
177 /*     err = slot_alloc(&tiler_cap); */
178 /*     if (err_is_fail(err)) { */
179 /*         DEBUG_ERR(err, "slot_alloc failed. Step 1\n"); */
180 /*         return (err); */
181 /*     } */
182
183 /*     err = cap_retype(device_range_cap, requested_caps, ObjType_DevFrame, 29); */
184
185 /*     struct capref l3_ocm_ram = NULL_CAP; */
186
187 /*     err = slot_alloc(&l3_ocm_ram); */
188 /*     if (err_is_fail(err)) { */
189 /*         DEBUG_ERR(err, "slot_alloc failed. Step 2\n"); */
190 /*         return (err); */
191 /*     } */
192
193 /*     err = cap_retype(l3_ocm_ram, device_range_cap, ObjType_DevFrame, 26); */
194 /*     if (err_is_fail(err)) { */
195 /*         DEBUG_ERR(err, "failed to retype the dev cap. Step 3\n"); */
196 /*         return (err); */
197 /*     } */
198
199 /*     struct capref l3_config_registers_cap; */
200 /*     err = slot_alloc(&l3_config_registers_cap); */
201 /*     if (err_is_fail(err)) { */
202 /*         DEBUG_ERR(err, "slot alloc failed. Step 4\n"); */
203 /*         return (err); */
204 /*     } */
205
206 /*     struct capref l4_domains_cap; */
207 /*     err = slot_alloc(&l4_domains_cap); */
208 /*     if (err_is_fail(err)) { */
209 /*         DEBUG_ERR(err, "slot_alloc failed. Step 5\n"); */
210 /*         return (err); */
211 /*     } */
212
213 /*     struct capref emif_registers_cap; */
214 /*     err = slot_alloc(&emif_registers_cap); */
215 /*     if (err_is_fail(err)) { */
216 /*         DEBUG_ERR(err, "slot_alloc failed. Step 6\n"); */
217 /*         return (err); */
218 /*     } */
219
220 /*     struct capref gpmc_iss_cap; */
221 /*     err = slot_alloc(&gpmc_iss_cap); */
222 /*     if (err_is_fail(err)) { */
223 /*         DEBUG_ERR(err, "slot_alloc failed. Step 7\n"); */
224 /*         return (err); */
225 /*     } */
226
227 /*     struct capref l3_emu_m3_sgx_cap; */
228 /*     err = slot_alloc(&l3_emu_m3_sgx_cap); */
229 /*     if (err_is_fail(err)) { */
230 /*         DEBUG_ERR(err, "slot_alloc failed. Step 8\n"); */
231 /*         return (err); */
232 /*     } */
233
234 /*     struct capref display_iva_cap; */
235 /*     err = slot_alloc(&display_iva_cap); */
236 /*     if (err_is_fail(err)) { */
237 /*         DEBUG_ERR(err, "slot_alloc failed. Step 9\n"); */
238 /*         return (err); */
239 /*     } */
240 /*     struct capref tmp_cap = display_iva_cap; */
241 /*     tmp_cap.slot++; */
242 /*     cap_delete(tmp_cap); */
243
244 /*     struct capref l4_PER_domain_cap; */
245 /*     err = slot_alloc(&l4_PER_domain_cap); */
246 /*     if (err_is_fail(err)) { */
247 /*         DEBUG_ERR(err, "slot_alloc failed. Step 12\n"); */
248 /*         return (err); */
249 /*     } */
250
251 /*     struct capref l4_ABE_domain_cap; */
252 /*     err = slot_alloc(&l4_ABE_domain_cap); */
253 /*     if (err_is_fail(err)) { */
254 /*         DEBUG_ERR(err, "slot_alloc failed. Step 11\n"); */
255 /*         return (err); */
256 /*     } */
257
258 /*     struct capref l4_CFG_domain_cap; */
259 /*     err = slot_alloc(&l4_CFG_domain_cap); */
260 /*     if (err_is_fail(err)) { */
261 /*         DEBUG_ERR(err, "slot_alloc failed. Step 12\n"); */
262 /*         return (err); */
263 /*     } */
264
265 /*     err = cap_retype(l4_PER_domain_cap, l4_domains_cap, ObjType_DevFrame, 24); */
266 /*     if (err_is_fail(err)) { */
267 /*         DEBUG_ERR(err, "failed to retype the cap. Step 13\n"); */
268 /*         return (err); */
269 /*     } */
270 /*     tmp_cap = l4_CFG_domain_cap; */
271 /*     tmp_cap.slot++; */
272 /*     cap_delete(tmp_cap); */
273
274 /*     struct frame_identity frameid;  // = {        0,        0    }; */
275
276 /*     err = invoke_frame_identify(l4_CFG_domain_cap, &frameid); */
277 /*     if (err_is_fail(err)) { */
278 /*         DEBUG_ERR(err, "could not identify the frame. Step 14\n"); */
279 /*     } */
280
281 /*     // get the 32 bit */
282 /*     uint32_t last = (uint32_t) (0xFFFFFFFF & (frameid.base)); */
283 /*     uint32_t size2 = frameid.bits; */
284
285 /*     /\* the L4 CFG domain cap must have address 0x4A000000 *\/ */
286 /*     assert(last == 0x4a000000); */
287
288 /*     /\* the size of the L4 CFG domain is 16k *\/ */
289 /*     assert(((1 << size2) / 1024) == (16 * 1024)); */
290
291 /* #define USB_SUBSYSTEM_L4_OFFSET 0x00062000 */
292 /* //#define USB_OHCI_OFFSET         (0x000A9000-USB_SUBSYSTEM_L4_OFFSET) */
293 /* #define USB_OHCI_OFFSET         0x00002800 */
294 /* #define USB_EHCI_OFFSET         0x00002C00 */
295
296 /* #define USB_ARM_EHCI_IRQ 109 */
297
298 /*     uint32_t tmp = (uint32_t) USB_EHCI_OFFSET + USB_SUBSYSTEM_L4_OFFSET; */
299
300 /*     char buf[255]; */
301 /*     uint8_t offset = 0; */
302 /*     driver->cmdargs = buf; */
303 /*     driver->argc = 3; */
304 /*     driver->argv[0] = driver->cmdargs+0; */
305
306 /*     snprintf(buf+offset, 255-offset, "ehci\0"); */
307 /*     offset += strlen(driver->argv[0])+1; */
308 /*     driver->argv[1] = driver->cmdargs+offset; */
309 /*     snprintf(buf+offset, 255-offset, "%u\0", tmp); */
310 /*     offset += strlen(driver->argv[1])+1; */
311 /*             driver->argv[2] = driver->cmdargs+offset; */
312 /*     snprintf(buf+offset, 255-offset, "%u\0", USB_ARM_EHCI_IRQ); */
313
314 /*     err = SYS_ERR_OK; */
315 /*     coreid_t core = 0; */
316
317 /*     if (is_started(driver)) { */
318 /*         debug_printf("driver is already started..."); */
319 /*         return KALUGA_ERR_DRIVER_ALREADY_STARTED; */
320 /*     } */
321
322 /*     err = spawn_program_with_caps(core, driver->path, driver->argv, environ, */
323 /*             NULL_CAP, l4_CFG_domain_cap, 0, &driver->did); */
324 /*     if (err_is_fail(err)) { */
325 /*         DEBUG_ERR(err, "Spawning %s failed.", driver->path); */
326 /*         return err; */
327 /*     } */
328
329 /*     return err; */
330 /* } */