Added some bug fixes to the Xeon Phi Driver
authorReto Achermann <acreto@student.ethz.ch>
Sun, 18 May 2014 14:16:55 +0000 (16:16 +0200)
committerStefan Kaestle <stefan.kaestle@inf.ethz.ch>
Wed, 20 Aug 2014 15:05:01 +0000 (17:05 +0200)
devices/xeon_phi/xeon_phi_boot.dev
tools/xloader/Hakefile
tools/xloader/loader.c
usr/drivers/xeon_phi/boot.c
usr/drivers/xeon_phi/serial.c

index 837bd24..62e7e5a 100644 (file)
@@ -20,6 +20,16 @@ device xeon_phi_boot lsbfirst ( addr sbox_base, addr dbox_base ) "Intel Xeon Phi
      * Reset Dmain: CSR_RESET, HOT_RESET
      * Register Access: TRM
      */
+     
+     register flash_ctrl rw addr(sbox_base, 0xAB24) {
+        percent    7 "Percentage progress";
+        status     4 "Status code";
+        command    4 "flash command";
+        smc_status 4 "SMC Status";
+        _          5 "Reserved";
+        cmd_data   7 "Command Data";
+        mm_debug   1 "Memory debug";
+     }; 
 
      constants offset width(32) "" {
          address_shift=12;
@@ -59,7 +69,7 @@ device xeon_phi_boot lsbfirst ( addr sbox_base, addr dbox_base ) "Intel Xeon Phi
     
     register meminfo rw addr(sbox_base, 0xAB20) {
           test_disable  1 "Memtest disable";
-          usage         2 "Memory usage";
+          usage         2 "Memory usage";      
           size_kb      29 "Memory size in KB";
     };
     
@@ -150,6 +160,7 @@ device xeon_phi_boot lsbfirst ( addr sbox_base, addr dbox_base ) "Intel Xeon Phi
         postcode_pf             = 0x4650 "PF INT 14 - Pagefault";
         postcode_rs             = 0x3572 "r5 INT 15 - Reserved";
         postcode_iop            = 0x6475 "ud INT 6 - Invalid OP code";
+        postcode_unknownerr        = 0x3048 "H0 Unknown Error, HALT";
     };
     
     constants postcodes_special width(32) "The Xeon Phi Post codes" {
index 4885de8..671fff4 100644 (file)
@@ -22,7 +22,7 @@ let arch = "k1om"
                                 "-std=c99",
                                 "-m64",
                                 "-fPIC", 
-                                "-e start_kernel",
+                                "-e startup_32",
                                 "-mno-red-zone",
                                 "-mk1om",
                                 "-Wa,-march=k1om",
@@ -44,6 +44,8 @@ let arch = "k1om"
                                 "-Werror",
                                 "-imacros deputy/nodeputy.h",
                                 "-fno-tree-vectorize",
+                                "-fno-builtin ",
+                                "-nostdlib ",
                                 "-mno-mmx",
                                 "-mno-sse",
                                 "-mno-sse2",
index f4df422..a8f64d2 100644 (file)
@@ -89,9 +89,6 @@ print_status(char a,
     s.vals[1] = a;
     s.vals[0] = '>';
 
-    while ((*p))
-        ;
-
     *p2 = s.raw;
     *p = 0x7A7A7A7A;
 }
@@ -105,6 +102,13 @@ eabort(char a,
         ;
 }
 
+static inline void notify_host(void)
+{
+    volatile uint32_t *p = (volatile uint32_t *) ((SBOX_BASE) + 0xAB28);
+    *p = (*p) | 0x1;
+}
+
+
 /*
  * ----------------------------------------------------------------------------
  *  ELF Utility Functions
@@ -194,6 +198,8 @@ loader(uint64_t magic,
 
     multiboot_info = get_multiboot();
 
+    print_status('S', '1');
+
     /*
      * Copy the multi boot image closer to the kernel
      */
@@ -202,7 +208,7 @@ loader(uint64_t magic,
 
     /* sanity check for the locations */
     if (mb_img_start > mb_img_orig) {
-        eabort('E', 'C');
+        eabort('E', '1');
     }
     memcpy((void *) mb_img_start, (void *) mb_img_orig, boot_hdr->ramdisk_size);
 
@@ -218,6 +224,7 @@ loader(uint64_t magic,
         mod->mod_end += mb_img_start;
         mod++;
     }
+    print_status('S', '2');
 
     /* look up the kernel module */
     struct multiboot_modinfo *kernel;
@@ -225,6 +232,9 @@ loader(uint64_t magic,
     if (kernel == NULL) {
         kernel = multiboot_find_module("kernel");
     }
+    if (kernel == NULL) {
+        eabort('E', '2');
+    }
 
     /* set the start address where we can allocate ram */
     phys_alloc_start = ROUND_UP(mb_img_start + boot_hdr->ramdisk_size,
@@ -247,12 +257,14 @@ loader(uint64_t magic,
     multiboot_info->config_table = (uint32_t)(uintptr_t)bootparam;
     multiboot_info->flags |= MULTIBOOT_INFO_FLAG_HAS_CONFIG;
 
+    print_status('S', '3');
+
     err = elf64_load(EM_K1OM, linear_alloc, NULL, kernel->mod_start,
                      MULTIBOOT_MODULE_SIZE(*kernel), &kernel_entry, NULL, NULL,
                      NULL);
 
     if (err_is_fail(err)) {
-        eabort('E', '1');
+        eabort('E', '3');
     }
 
     struct Elf64_Ehdr *cpu_head = (struct Elf64_Ehdr *) (uint64_t) kernel->mod_start;
@@ -267,6 +279,8 @@ loader(uint64_t magic,
 
     symtab = elf64_find_section_header_type(symhead, cpu_head->e_shnum, SHT_DYNSYM);
 
+    print_status('S', '4');
+
     elf64_relocate(
             kernel_start, elfbase,
             (struct Elf64_Rela *) (uintptr_t) (kernel->mod_start + rela->sh_offset),
@@ -276,8 +290,11 @@ loader(uint64_t magic,
 
     kernel_entry = kernel_entry - elfbase + kernel_start;
 
+    print_status('S', '5');
+
     set_elf_headers(kernel->mod_start);
-    print_status('S', '2');
+
+    print_status('S', '6');
 
     return kernel_entry;
 
index 07a48ac..679a35f 100644 (file)
@@ -56,10 +56,30 @@ static xeon_phi_apic_t apic_registers;
  */
 static inline lvaddr_t get_load_offset(struct xeon_phi *phi)
 {
+    return ((lvaddr_t)xeon_phi_boot_download_offset_rdf(&boot_registers))<<12;
+}
+
+
+static uint64_t get_adapter_memsize(void)
+{
+    xeon_phi_boot_meminfo_t meminfo = xeon_phi_boot_meminfo_rd(&boot_registers);
+
+    uint64_t memsize = xeon_phi_boot_meminfo_size_kb_extract(meminfo);
+    memsize *= 1024;
 
-    xeon_phi_boot_download_t offset;
-    offset = xeon_phi_boot_download_rawrd(&boot_registers);
-    return (offset & xeon_phi_boot_address_mask);
+    switch (xeon_phi_boot_meminfo_usage_extract(meminfo)) {
+        case xeon_phi_boot_mem_all:
+            return memsize;
+        case xeon_phi_boot_mem_half:
+            return (memsize / 2);
+        case xeon_phi_boot_mem_third:
+            return (memsize / 3);
+            break;
+        case xeon_phi_boot_mem_fourth:
+            return (memsize / 4);
+        default:
+            return memsize;
+    }
 }
 
 /**
@@ -96,16 +116,23 @@ static errval_t load_bootloader(struct xeon_phi *phi,
         return err_push(err, SPAWN_ERR_ELF_MAP);
     }
 
+    imgsize = module->mrmod_size;
+
     struct Elf64_Ehdr *head = (struct Elf64_Ehdr *) binary;
     if (head->e_machine != EM_K1OM) {
         return SPAWN_ERR_DETERMINE_CPUTYPE;
     }
 
+
     /*
-     * get the load offset: we do not want to write into the
+     * get the load offset: we do not want to write into the boot loade
      */
     lvaddr_t loadoffset = get_load_offset(phi);
 
+    get_adapter_memsize();
+
+    phi->apicid = xeon_phi_boot_download_apicid_rdf(&boot_registers);
+
     XBOOT_DEBUG("bootloader offset = 0x%lx\n", phi->apt.vbase + loadoffset);
 
     printf("Loading xloader onto card...\n");
@@ -155,6 +182,7 @@ static errval_t load_multiboot_image(struct xeon_phi *phi,
         return err_push(err, SPAWN_ERR_ELF_MAP);
     }
 
+    imgsize = module->mrmod_size;
 
     printf("Loading multiboot image onto card...\n");
     XBOOT_DEBUG("aper_base=0x%lx, offset = 0x%lx, size=0x%lx\n",
@@ -221,27 +249,9 @@ static errval_t bootstrap_notify(struct xeon_phi *phi,
     // 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;
-    }
+    uint64_t memsize = get_adapter_memsize();
 
-    uint32_t reserved = (uint32_t)(memsize * MEMORY_RESERVE_PERCENT / 100);
+    uint64_t reserved = (memsize * MEMORY_RESERVE_PERCENT / 100);
 
 
     // Keep in mind maximum uos reserve size is uint32_t, so we never overflow
@@ -249,11 +259,11 @@ static errval_t bootstrap_notify(struct xeon_phi *phi,
     reserved = MAX(reserved, UOS_RESERVE_SIZE_MIN);
 
     // Always align uos reserve size to a page
-    reserved = (uint32_t)(reserved & ~(BASE_PAGE_SIZE-1));
+    reserved = (reserved & ~(BASE_PAGE_SIZE-1));
 
-    XBOOT_DEBUG("memsize = 0x%x, reserved size = 0x%x\n", memsize, reserved);
+    XBOOT_DEBUG("memsize = 0x%lx, reserved size = 0x%lx\n", memsize, reserved);
 
-    xeon_phi_boot_res_size_rawwr(&boot_registers, reserved);
+    xeon_phi_boot_res_size_rawwr(&boot_registers, (uint32_t)reserved);
 
     // sending the bootstrap interrupt
     xeon_phi_apic_icr_lo_t icr_lo = xeon_phi_apic_icr_lo_default;
index 6eaa3d1..d540d9b 100644 (file)
@@ -49,7 +49,6 @@ static int xeon_phi_recv_handler(void *arg)
 
     debug_printf("xeon phi receive handler started. %d\n", xarg->xid);
 
-    xeon_phi_serial_ctrl_rawwr(&xarg->base, xeon_phi_serial_reset);
 
     nodata = XEON_PHI_POLL_GIVEUP;
 
@@ -153,6 +152,8 @@ errval_t serial_start_recv_thread(struct xeon_phi *phi)
 
     xeon_phi_serial_initialize(&xarg->base, XEON_PHI_MMIO_TO_SBOX(phi));
 
+    xeon_phi_serial_ctrl_rawwr(&xarg->base, xeon_phi_serial_reset);
+
     /*
      * xxx: maybe store the thread pointer
      */