Xeon Phi Host Side Driver
authorReto Achermann <acreto@student.ethz.ch>
Fri, 25 Apr 2014 11:34:33 +0000 (13:34 +0200)
committerStefan Kaestle <stefan.kaestle@inf.ethz.ch>
Wed, 20 Aug 2014 13:47:37 +0000 (15:47 +0200)
+ Getting access to multiboot modules
+ Extended the xeon phi device register specification with some values
+

Hake
+ Added the host driver and the host modules to menu list

devices/xeon_phi/xeon_phi_apic.dev
hake/menu.lst.x86_64
hake/symbolic_targets.mk
usr/drivers/xeon_phi/Hakefile
usr/drivers/xeon_phi/boot.c
usr/drivers/xeon_phi/host_bootstrap.c [new file with mode: 0644]
usr/drivers/xeon_phi/main.c
usr/drivers/xeon_phi/serial.c
usr/drivers/xeon_phi/xeon_phi.h

index 1bc6992..5b9c188 100644 (file)
 
 device xeon_phi_apic lsbfirst ( addr base ) "Intel Xeon Phi APIC register" {
 
+     constants irq_vec width(32) "Interupt Vectors" {
+          vec_bsp = 229;
+     };
+     
+     constants irq_idx width(3) "Interrupt Register Index" {
+          vnet      = 0;
+          sht       = 1;
+          hvc       = 2;
+          virtio    = 3;
+          pm        = 4;
+          unused    = 5;
+          unused2   = 6;
+          bootstrap = 7;
+     };
+     
+
+    constants dst_shorthand "Destination shorthand" {
+      none    = 0b00 "No shorthand";
+      self    = 0b01 "Self";
+      all_inc = 0b10 "All including self";
+      all_exc = 0b11 "All excluding self";
+    };
+
+    constants dst_mode "Destination mode" {
+      dst_phys        = 0b00 "Physical";
+      dst_log         = 0b01 "Logical";
+    };
+
+    constants int_level "Interrupt level" {
+      lvl_clr         = 0b00 "Clear";
+      lvl_set         = 0b01 "Set";
+    };
+    
+    constants vdm "Vector delivery mode" { 
+      fixed   = 0b000 "Fixed";
+      lowest  = 0b001 "Lowest priority";
+      smi     = 0b010 "SMI";
+      nmi     = 0b100 "NMI";
+      init    = 0b101 "INIT";
+      startup = 0b110 "Start Up";
+      extint  = 0b111 "ExtINT";
+    };
+    
+    constants trigm "Trigger mode" {
+      edge  = 0 "Edge";
+      level = 1 "Level";
+    };
+
     /*
      * Protection Level: Ring 0
      * Visibility: Host / Coprocessor
      * Reset Dmain: GRPB_RESET
      * Register Access: CRU
      */
-    register idr rw addr(base, 0xA800) "APIC Identification Register" { 
-        value 32 "Value";
+    register id rw addr(base, 0xA800) "APIC Identification Register" { 
+        _   23;
+        id  9 "apic id";
     };
 
     /*
@@ -32,8 +81,11 @@ device xeon_phi_apic lsbfirst ( addr base ) "Intel Xeon Phi APIC register" {
      * Reset Dmain: GRPB_RESET
      * Register Access: CRU
      */
-    register ver rw addr(base, 0xA804) "APIC Version Register" { 
-        value 32 "Value";
+    register version rw addr(base, 0xA804) "APIC Version Register" { 
+        ver      8 "version";
+        _        8;
+        max_lvt  8 "max LVT entry";
+        _        8;
     };
 
     /*
@@ -42,7 +94,7 @@ device xeon_phi_apic lsbfirst ( addr base ) "Intel Xeon Phi APIC register" {
      * Reset Dmain: GRPB_RESET
      * Register Access: CRU
      */
-    register pr rw addr(base, 0xA808) "APIC Prioroty Register" { 
+    register pr rw addr(base, 0xA808) "APIC Priority Register" { 
         value 32 "Value";
     };
 
@@ -64,9 +116,22 @@ device xeon_phi_apic lsbfirst ( addr base ) "Intel Xeon Phi APIC register" {
      * Register Access: CRU
      * Number: 8
      */
-    regarray icr rw addr(base, 0x9D0) [8] "APIC Interrupt Command Register 0 to 7" { 
-        value 64 "Value";
+    regarray icr_lo rw addr(base, 0x9D0) [8; 0x8] "APIC Interrupt Command Register 0 to 7" { 
+        vector      8 "Vector";
+        dlv_mode    3 type(vdm) "Delivery mode";
+        dst_mode    1 type(dst_mode) "Destination mode";
+        dlv_stat    1 ro "Delivery status";
+        _           1;
+        level       1 type(int_level) "Level";
+        trig_mode   1 type(trigm) "Trigger mode";
+        _           2;
+        dst_short   2 type(dst_shorthand) "Destination shorthand";
+        _           12;
     };            
+    
+    regarray icr_hi rw addr(base, 0x9D4) [8; 0x8]  "APIC Interrupt Command Register 0 to 7" { 
+        dest        32 "Destination field";
+    }; 
 
 
 };
\ No newline at end of file
index 786c689..27dd36f 100644 (file)
@@ -24,6 +24,8 @@ module        /x86_64/sbin/monitor
 module  /x86_64/sbin/ramfsd boot
 module  /x86_64/sbin/skb boot
 modulenounzip /skb_ramfs.cpio.gz nospawn
+modulenounzip /xeon_phi_mbimage nospawn
+module  /xeon_phi_xloader nospawn
 module  /x86_64/sbin/kaluga boot
 module  /x86_64/sbin/acpi boot
 module  /x86_64/sbin/spawnd boot
@@ -31,27 +33,29 @@ module  /x86_64/sbin/spawnd boot
 module  /x86_64/sbin/startd boot
 module /x86_64/sbin/routing_setup boot
 
+
 # Drivers
 module /x86_64/sbin/pci auto
 module /x86_64/sbin/ahcid auto
+module  /x86_64/sbin/xeon_phi auto
 
 ## For networking
 ## For qemu, enable rtl8029
-module /x86_64/sbin/rtl8029 auto
+#module /x86_64/sbin/rtl8029 auto
 
 ## For real hardware, enable e1000n
-module /x86_64/sbin/e1000n auto
+#module /x86_64/sbin/e1000n auto
 
 ## Other services needed for networking
-module /x86_64/sbin/NGD_mng auto
-module /x86_64/sbin/netd auto
+#module /x86_64/sbin/NGD_mng auto
+#module /x86_64/sbin/netd auto
 
 ## Block Service
-module /x86_64/sbin/block_server
-module /x86_64/sbin/block_server_client
-module /x86_64/sbin/bs_user
+#module /x86_64/sbin/block_server
+#module /x86_64/sbin/block_server_client
+#module /x86_64/sbin/bs_user
 
 # General user domains
-module /x86_64/sbin/serial
-module  /x86_64/sbin/fish nospawn
-module /x86_64/sbin/angler serial0.terminal xterm
+#module        /x86_64/sbin/serial
+#module  /x86_64/sbin/fish nospawn
+#module        /x86_64/sbin/angler serial0.terminal xterm
index d5209f3..d7727cd 100644 (file)
@@ -172,6 +172,7 @@ MODULES_x86_64= \
        sbin/angler \
        sbin/sshd \
        sbin/lshw \
+       sbin/xeon_phi \
 #      sbin/block_server \
 #      sbin/block_server_client \
 #      sbin/bs_user \
index 0965e94..ec6ec58 100644 (file)
 --------------------------------------------------------------------------
 
 [ build application { target = "xeon_phi",
-                      cFiles = [ "main.c", "boot.c", "serial.c" ],
+                      cFiles = [ "main.c", 
+                                 "boot.c", 
+                                 "serial.c", 
+                                 "host_bootstrap.c" ],
                       addLibraries = libDeps ["skb", "pci", "spawndomain", "elf" ],
+                      flounderExtraDefs = [ ("monitor_blocking",["rpcclient"]) ],
+                      flounderDefs = ["monitor"],
                       architectures= ["x86_64"],
                       mackerelDevices = [ "xeon_phi/xeon_phi_apic", 
                                           "xeon_phi/xeon_phi_boot", 
                                           "xeon_phi/xeon_phi_serial"]
                     }
 ]
+
+
+      
+                      
+                      
+                          
\ No newline at end of file
index 1f749b9..533e2c1 100644 (file)
 #include <dev/xeon_phi/xeon_phi_boot_dev.h>
 #include <dev/xeon_phi/xeon_phi_apic_dev.h>
 
-#include "xeon_phi.h"
+struct bootinfo *bi = NULL;
 
+#include "xeon_phi.h"
 
 static xeon_phi_boot_t boot_registers;
+static xeon_phi_apic_t apic_registers;
 
 /**
  * \brief   get the load offset to where to place the bootloader
@@ -34,8 +36,7 @@ static xeon_phi_boot_t boot_registers;
  * The bootstrap on the card will write the offset into the SBOX_SCRATCH2
  * register once the bootstrap is finished
  */
-static inline lvaddr_t
-get_load_offset(struct xeon_phi *phi)
+static inline lvaddr_t get_load_offset(struct xeon_phi *phi)
 {
 
     xeon_phi_boot_download_t offset;
@@ -51,17 +52,16 @@ get_load_offset(struct xeon_phi *phi)
  * \param ret_imgsize   returned image size
  * \param ret_cmdoffset returned offset to load the next piece onto the card
  */
-static errval_t
-load_os(struct xeon_phi *phi,
-        char *xloader_img,
-        uint32_t *ret_imgsize,
-        lvaddr_t *ret_cmdoffset)
+static errval_t load_os(struct xeon_phi *phi,
+                        char *xloader_img,
+                        uint32_t *ret_imgsize,
+                        lvaddr_t *ret_cmdoffset)
 {
     errval_t err;
     /*
      * find the boot loader image in the host multiboot
      */
-    struct mem_region *module = multiboot_find_module(NULL, xloader_img);
+    struct mem_region *module = multiboot_find_module(bi, xloader_img);
     if (module == NULL) {
         return SPAWN_ERR_FIND_MODULE;
     }
@@ -85,10 +85,12 @@ load_os(struct xeon_phi *phi,
     lvaddr_t loadoffset = get_load_offset(phi);
 
     printf("Loading xloader onto card...\n");
-    XBOOT_DEBUG("aper_base=0x%lx, offset = 0x%lx, size=0x%lx\n", phi->aper_base,
-                loadoffset, imgsize);
+    XBOOT_DEBUG("aper_base=0x%lx, offset = 0x%lx, size=0x%lx\n",
+                phi->aper_base,
+                loadoffset,
+                imgsize);
 
-    memcpy((void *) (phi->aper_base + loadoffset), (void *)binary, imgsize);
+    memcpy((void *) (phi->aper_base + loadoffset), (void *) binary, imgsize);
 
     if (ret_cmdoffset) {
         *ret_cmdoffset = loadoffset + imgsize;
@@ -104,17 +106,16 @@ load_os(struct xeon_phi *phi,
 /**
  *
  */
-static errval_t
-load_multiboot_image(struct xeon_phi *phi,
-                     char *multiboot_img,
-                     lvaddr_t load_offset,
-                     uint32_t *ret_imgsize)
+static errval_t load_multiboot_image(struct xeon_phi *phi,
+                                     char *multiboot_img,
+                                     lvaddr_t load_offset,
+                                     uint32_t *ret_imgsize)
 {
     errval_t err;
     /*
      * find the boot loader image in the host multiboot
      */
-    struct mem_region *module = multiboot_find_module(NULL, multiboot_img);
+    struct mem_region *module = multiboot_find_module(bi, multiboot_img);
     if (module == NULL) {
         return SPAWN_ERR_FIND_MODULE;
     }
@@ -130,10 +131,12 @@ load_multiboot_image(struct xeon_phi *phi,
     lvaddr_t os_offset = get_load_offset(phi);
 
     printf("Loading multiboot image onto card...\n");
-    XBOOT_DEBUG("aper_base=0x%lx, offset = 0x%lx, size=0x%lx\n", phi->aper_base,
-                load_offset, imgsize);
+    XBOOT_DEBUG("aper_base=0x%lx, offset = 0x%lx, size=0x%lx\n",
+                phi->aper_base,
+                load_offset,
+                imgsize);
 
-    memcpy((void *) (phi->aper_base + load_offset), (void *)image, imgsize);
+    memcpy((void *) (phi->aper_base + load_offset), (void *) image, imgsize);
 
     /*
      * we are using the Linux style way in booting. The following will update
@@ -154,10 +157,9 @@ load_multiboot_image(struct xeon_phi *phi,
  * \param   load_offset offset where to load the cmdline
  * \param   ret_size    size of the cmdline in bytes
  */
-static errval_t
-load_cmdline(struct xeon_phi *phi,
-             lvaddr_t load_offset,
-             uint32_t *ret_size)
+static errval_t load_cmdline(struct xeon_phi *phi,
+                             lvaddr_t load_offset,
+                             uint32_t *ret_size)
 {
     uint32_t cmdlen = 0;
     void *buf = (void *) (phi->aper_base + load_offset);
@@ -179,25 +181,64 @@ load_cmdline(struct xeon_phi *phi,
     return SYS_ERR_OK;
 }
 
-static errval_t
-bootstrap_notify(struct xeon_phi *phi,
-                 uint32_t os_imgsize)
+static errval_t bootstrap_notify(struct xeon_phi *phi,
+                                 uint32_t os_imgsize)
 {
-#if 0
-    uint32_t scratch5;
+    // set the bootimage size to tell the bootloader
+    xeon_phi_boot_os_size_rawwr(&boot_registers, os_imgsize);
+
+    xeon_phi_boot_meminfo_t meminfo = xeon_phi_boot_meminfo_rd(&boot_registers);
+
+    uint32_t memsize = xeon_phi_boot_meminfo_size_kb_extract(meminfo) * 1024;
+
+    switch (xeon_phi_boot_meminfo_usage_extract(meminfo)) {
+        case xeon_phi_boot_mem_all:
+            memsize /= 1;
+            break;
+        case xeon_phi_boot_mem_half:
+            memsize /= 2;
+            break;
+
+        case xeon_phi_boot_mem_third:
+            memsize /= 3;
+            break;
+        case xeon_phi_boot_mem_fourth:
+            memsize /= 4;
+            break;
+    }
+
+    uint32_t reserved = (uint32_t)(memsize * MEMORY_RESERVE_PERCENT / 100);
+
+
+    // Keep in mind maximum uos reserve size is uint32_t, so we never overflow
+    reserved = MIN(reserved, UOS_RESERVE_SIZE_MAX);
+    reserved = MAX(reserved, UOS_RESERVE_SIZE_MIN);
+
+    // Always align uos reserve size to a page
+    reserved = (uint32_t)(reserved & ~(BASE_PAGE_SIZE-1));
+
+    XBOOT_DEBUG("memsize = 0x%x, reserved size = 0x%x\n", memsize, reserved);
+
+    xeon_phi_boot_res_size_wr(&boot_registers, reserved);
 
-    scratch5 = os_imgsize;
-    // XPU_RACE_CONDITION: write to MMIO space is uncached and flushes WC buffers
-    SBOX_WRITE(scratch5, mmio_va, SBOX_SCRATCH5);
+    // sending the bootstrap interrupt
+    xeon_phi_apic_icr_lo_t icr_lo = xeon_phi_apic_icr_lo_default;
+    icr_lo = xeon_phi_apic_icr_lo_vector_insert(icr_lo, xeon_phi_apic_vec_bsp);
+    icr_lo = xeon_phi_apic_icr_lo_dlv_stat_insert(icr_lo, 0x1);
 
-    get_adapter_memsize(mmio_va, &adapter_memsize);
+    assert(icr_lo == (229 | (1 << 13)));
 
-    // Program the register to inform the uOS of how much space to reserve
-    get_uos_reserved_size(mmio_va, adapter_memsize, &uos_reserved_size);
-    set_uos_reserved_size(mmio_va, uos_reserved_size);
+    xeon_phi_apic_icr_hi_wr(&apic_registers, xeon_phi_apic_bootstrap, phi->apicid);
 
+
+
+    xeon_phi_apic_icr_lo_wr(&apic_registers, xeon_phi_apic_bootstrap, icr_lo);
+
+
+#if 0
     mic_send_bootstrap_intr(mic_ctx);
 #endif
+
     return SYS_ERR_OK;
 }
 
@@ -208,17 +249,20 @@ bootstrap_notify(struct xeon_phi *phi,
  * \param xloader_img   pointer to the card bootloader image
  * \param multiboot_img pointer to the card multiboot image
  */
-errval_t
-xeon_phi_boot(struct xeon_phi *phi,
-              char *xloader_img,
-              char *multiboot_img)
+errval_t xeon_phi_boot(struct xeon_phi *phi,
+                       char *xloader_img,
+                       char *multiboot_img)
 {
     errval_t err;
     lvaddr_t offset;
     uint32_t size, osimg_size;
 
-    xeon_phi_boot_initialize(&boot_registers, XEON_PHI_MMIO_TO_SBOX(phi->mmio_base));
+    if (bi == NULL) {
+        return SYS_ERR_ILLEGAL_INVOCATION;
+    }
 
+    xeon_phi_boot_initialize(&boot_registers, XEON_PHI_MMIO_TO_SBOX(phi->mmio_base));
+    xeon_phi_apic_initialize(&apic_registers, XEON_PHI_MMIO_TO_SBOX(phi->mmio_base));
     // load the coprocessor OS
     err = load_os(phi, xloader_img, &osimg_size, &offset);
     if (err_is_fail(err)) {
@@ -232,7 +276,7 @@ xeon_phi_boot(struct xeon_phi *phi,
     }
 
     // round to next page
-    offset  += size + BASE_PAGE_SIZE - (size & (BASE_PAGE_SIZE - 1 ));
+    offset += size + BASE_PAGE_SIZE - (size & (BASE_PAGE_SIZE - 1));
 
     // load multiboot image
     err = load_multiboot_image(phi, multiboot_img, offset, &size);
@@ -254,8 +298,7 @@ xeon_phi_boot(struct xeon_phi *phi,
  *
  * \param phi   pointer to the card information
  */
-errval_t
-xeon_phi_reset(struct xeon_phi *phi)
+errval_t xeon_phi_reset(struct xeon_phi *phi)
 {
     return SYS_ERR_OK;
 }
diff --git a/usr/drivers/xeon_phi/host_bootstrap.c b/usr/drivers/xeon_phi/host_bootstrap.c
new file mode 100644 (file)
index 0000000..9c49a27
--- /dev/null
@@ -0,0 +1,134 @@
+/**
+ * \file
+ * \brief Boot module for the Xeon Phi
+ *
+ * Loads the co processor OS onto the card and boots it
+ */
+
+/*
+ * Copyright (c) 2014 ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <barrelfish/barrelfish.h>
+#include <barrelfish/nameservice_client.h>
+#include <spawndomain/spawndomain.h>
+
+#include <if/monitor_defs.h>
+#include <if/monitor_blocking_rpcclient_defs.h>
+
+#include "xeon_phi.h"
+
+extern struct bootinfo *bi;
+extern volatile uint32_t bootstrap_done;
+
+/**
+ * \brief reply handler for the multiboot cap transfers
+ *
+ *
+ */
+static void multiboot_cap_reply(struct monitor_binding *st,
+                                struct capref cap,
+                                errval_t msgerr)
+{
+    errval_t err;
+    static cslot_t multiboot_slots = 0;
+
+    /*
+     * this indicates that there are no more multiboot caps available
+     * so we got everything
+     */
+    if (err_is_fail(msgerr)) {
+        DEBUG_ERR(msgerr, "We have all multiboot modules...");
+
+        struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+        if (cl == NULL) {
+            USER_PANIC("Could not get a connection to monitor RPC client\n");
+        }
+
+        struct capref bootinfo_frame;
+        size_t bootinfo_size;
+
+        msgerr = cl->vtbl.get_bootinfo(cl, &err, &bootinfo_frame, &bootinfo_size);
+        if (err_is_fail(msgerr)) {
+            USER_PANIC_ERR(err, "Could not request bootinfo from monitor.\n");
+        }
+
+        err = vspace_map_one_frame((void**) bi,
+                                   bootinfo_size,
+                                   bootinfo_frame,
+                                   NULL,
+                                   NULL);
+
+        if (err_is_fail(err)) {
+            USER_PANIC_ERR(err, "Could not map bootinfo frame in our VSPACE\n");
+        }
+
+        bootstrap_done = 1;
+    }
+
+    /*
+     * we got a new cap, move it to the correct location in our CSPACE
+     */
+    struct capref dest = {
+        .cnode = cnode_module,
+        .slot = multiboot_slots++,
+    };
+
+    err = cap_copy(dest, cap);
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "Could not copy the cap");
+    }
+
+    err = cap_destroy(cap);
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "Destroying the received cap failed");
+    }
+
+    err = st->tx_vtbl.multiboot_cap_request(st, NOP_CONT, multiboot_slots);
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "Sending the next multiboot request failed");
+    }
+}
+
+/**
+ * \brief Bootstraps the host driver to get the multiboot images of the
+ *        xeon phi loader and the xeon phi multiboot image
+ */
+errval_t host_bootstrap(void)
+{
+    errval_t err;
+
+    /* Create the module cnode */
+    struct capref modulecn_cap = {
+        .cnode = cnode_root,
+        .slot = ROOTCN_SLOT_MODULECN
+    };
+
+    err = cnode_create_raw(modulecn_cap,
+                           NULL,
+                           ((cslot_t) 1 << MODULECN_SIZE_BITS),
+                           NULL);
+
+    if (err_is_fail(err)) {
+        DEBUG_ERR(err, "cnode_create_raw failed");
+        return err;
+    }
+
+    struct monitor_binding *st = get_monitor_binding();
+    st->rx_vtbl.multiboot_cap_reply = multiboot_cap_reply;
+
+    // Make first multiboot cap request
+    err = st->tx_vtbl.multiboot_cap_request(st, NOP_CONT, 0);
+    if (err_is_fail(err)) {
+        return err;
+    }
+
+    return SYS_ERR_OK;
+}
index 7397040..ed07e4c 100644 (file)
  * ETH Zurich D-INFK, Universitaetsstrasse 6, CH-8092 Zurich. Attn: Systems Group.
  */
 
+#include <stdio.h>
+#include <string.h>
+#include <barrelfish/barrelfish.h>
 
-int main(int argc, char *argv[]) {
+#include "xeon_phi.h"
+
+volatile uint32_t bootstrap_done = 0;
+
+int main(int argc,
+         char *argv[])
+{
+    debug_printf("Xeon Phi host module started.\n");
+
+    host_bootstrap();
+
+    while (bootstrap_done == 0) {
+        messages_wait_and_handle_next();
+    }
+
+    debug_printf("Host bootstrap done\n");
 
     return 0;
 }
index d1c2655..f63ac54 100644 (file)
@@ -16,7 +16,6 @@
 #include <string.h>
 #include <barrelfish/barrelfish.h>
 
-
 #include <dev/xeon_phi/xeon_phi_serial_dev.h>
 
 #include "xeon_phi.h"
@@ -28,8 +27,8 @@ static xeon_phi_serial_t mmio_serial;
 
 uint8_t xeon_phi_id = 0;
 
-static inline void
-xprintf(uint8_t xid, char *fmt)
+static inline void xprintf(uint8_t xid,
+                           char *fmt)
 {
     printf("\033[34m>> XEON_PHI\033[31m%u\033[0m: %s", xid, fmt);
 }
@@ -38,12 +37,11 @@ struct xeon_phi_arg
 {
     xeon_phi_serial_t base;
     uint8_t xid;
-    char buffer[XEON_PHI_BUFFER_LENGTH+1];
+    char buffer[XEON_PHI_BUFFER_LENGTH + 1];
     uint32_t idx;
 };
 
-static int
-xeon_phi_recv_handler(void *arg)
+static int xeon_phi_recv_handler(void *arg)
 {
     struct xeon_phi_arg *xarg = arg;
     uint32_t nodata;
@@ -102,7 +100,8 @@ xeon_phi_recv_handler(void *arg)
             }
             if (has_data != xeon_phi_serial_data) {
                 debug_printf("[xeon phi %d] : ERROR invalid ctrl value.%x\n",
-                             xarg->xid, has_data);
+                             xarg->xid,
+                             has_data);
             }
             /* always issue a new line */
             if (value == '\n') {
@@ -142,8 +141,7 @@ xeon_phi_recv_handler(void *arg)
  *
  * The sbox memory region has already been mapped
  */
-errval_t
-serial_start_recv_thread(struct xeon_phi *phi)
+errval_t serial_start_recv_thread(struct xeon_phi *phi)
 {
     struct xeon_phi_arg *xarg = malloc(sizeof(struct xeon_phi_arg));
     if (xarg == NULL) {
index 95b7863..cf75417 100644 (file)
 #define XBOOT_DEBUG(x...) debug_printf(" BOOT | " x)
 //#define XBOOT_DEBUG(x...)
 
+#define MAX(a, b)   ( ((a) > (b)) ? (a) : (b) )
+#define MIN(a, b)   ( ((a) < (b)) ? (a) : (b) )
+
+/*
+ * TODO: Verify these values if they are really needed
+ */
+#define MEMORY_RESERVE_PERCENT 50
+#define UOS_RESERVE_SIZE_MIN    ((128) * 1024 * 1024)
+#define UOS_RESERVE_SIZE_MAX    (((4) * 1024 * 1024 * 1024ULL) - ((4) * 1024))
+
 struct xeon_phi
 {
     lvaddr_t mmio_base;     ///< base address of the MMIO register space
@@ -40,8 +50,7 @@ struct xeon_phi
  *
  * \param phi   pointer to the card information
  */
-errval_t
-serial_start_recv_thread(struct xeon_phi *phi);
+errval_t serial_start_recv_thread(struct xeon_phi *phi);
 
 /**
  * \brief boots the card with the given loader and multiboot image
@@ -50,8 +59,7 @@ serial_start_recv_thread(struct xeon_phi *phi);
  * \param xloader_img   pointer to the card bootloader image
  * \param multiboot_img pointer to the card multiboot image
  */
-errval_t
-xeon_phi_boot(struct xeon_phi *phi,
+errval_t xeon_phi_boot(struct xeon_phi *phi,
               char *xloader_img,
               char *multiboot_img);
 
@@ -60,7 +68,12 @@ xeon_phi_boot(struct xeon_phi *phi,
  *
  * \param phi   pointer to the card information
  */
-errval_t
-xeon_phi_reset(struct xeon_phi *phi);
+errval_t xeon_phi_reset(struct xeon_phi *phi);
+
+/**
+ * \brief Bootstraps the host driver to get the multiboot images of the
+ *        xeon phi loader and the xeon phi multiboot image
+ */
+errval_t host_bootstrap(void);
 
 #endif /* XEON_PHI_H_ */