system/kernel/ke/smp.c

   1 /*
   2 Copyright (C) 2008  Mathias Gottschlag
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy of
   5 this software and associated documentation files (the "Software"), to deal in the
   6 Software without restriction, including without limitation the rights to use,
   7 copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   8 Software, and to permit persons to whom the Software is furnished to do so,
   9 subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in all
  12 copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  15 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  17 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  18 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  19 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20 */
  21
  22 #include "ke/cpu.h"
  23 #include "ke/smp.h"
  24 #include "ke/debug.h"
  25 #include "ke/apic.h"
  26 #include "ke/timer.h"
  27 #include "mm/memory.h"
  28 #include "ke/gdt.h"
  29 #include <string.h>
  30 #include <stdlib.h>
  31
  32 extern uint32_t kernel_directory[1024];
  33
  34 char bootstrap_stack[0x4000] __attribute__ ((aligned (4096)));
  35
  36 volatile uint32_t start_aps = 0;
  37
  38 void keInitPIC2(void);
  39
  40 void keSMPEntry(void)
  41 {
  42         keInitPIC2();
  43
  44         while (!start_aps)
  45         {
  46                 char *cpusign = (char*)0xC00B8000 + keAPICGetCPU() * 2;
  47                 cpusign[0] = 'k';
  48                 cpusign[1]++;
  49         }
  50         keFlushGDT();
  51         asm volatile("ltrw %%ax"::"a"(0x28 + keAPICGetCPU() * 8));
  52
  53         char *vidmem = (char*)0xc00B8000;
  54
  55         char *cpusign = vidmem + keAPICGetCPU() * 2;
  56         cpusign[0] = 'K';
  57         cpusign[1] = 'A';
  58
  59         keAPICWrite(0x80, 0x20);
  60         keAPICWrite(0x320, 0x10000);
  61         keAPICWrite(0x340, 0x10000);
  62         keAPICWrite(0x350, 0x8700);
  63         keAPICWrite(0x360, 0x400);
  64         keAPICWrite(0x370, 0x10000);
  65         // Activate APIC
  66         keAPICWrite(0xF0, 0x10F);
  67
  68         keInstallTimer();
  69         asm("sti");
  70         while (1) asm("hlt");
  71 }
  72
  73 static FloatingPointerStruct *keFindFloatingPointerStruct(void);
  74
  75 extern uint32_t kernel_stack[];
  76
  77 void keInitSMP(void)
  78 {
  79         // Find smp info
  80         FloatingPointerStruct *fps = keFindFloatingPointerStruct();
  81         if (!fps)
  82         {
  83                 kePrint("No SMP!\n");
  84                 keAddCPU(keAPICGetCPU());
  85                 return;
  86         }
  87         else
  88         {
  89                 kePrint("SMP configuration table: %X\n", fps->configtable);
  90                 if (fps->configtable == 0)
  91                 {
  92                         kePrint("Error: Default SMP configurations not supported.\n");
  93                         mmMapKernelMemory(0, (uint32_t)fps & ~0xFFF, 0);
  94                         return;
  95                 }
  96
  97                 // Load configuration table
  98                 SMPConfigTable *config = (SMPConfigTable*)mmFindFreeKernelPages(MM_MAX_KERNEL_PAGE,
  99                         MM_MIN_KERNEL_PAGE, 1, 0x1000);
 100                 mmMapKernelMemory(fps->configtable & ~0xFFF, (uintptr_t)config,
 101                         MM_MAP_READ | MM_MAP_WRITE);
 102                 config = (SMPConfigTable*)((char*)config + (fps->configtable & 0xFFF));
 103
 104                 kePrint("Table entries: %d\n", config->entrycount);
 105
 106                 // TODO: This still can crash when we step upon the next page!
 107                 uint32_t max_lapic_id = 0;
 108                 uint32_t bootstrap_id = 0;
 109                 uintptr_t *stacks = malloc(sizeof(uintptr_t));
 110                 uint8_t *entry = (uint8_t*)config + sizeof(SMPConfigTable);
 111                 uint32_t i;
 112                 for (i = 0; i < config->entrycount; i++)
 113                 {
 114                         switch (*entry)
 115                         {
 116                                 case 0:
 117                                 {
 118                                         // CPU
 119                                         SMPProcessorEntry *processor = (SMPProcessorEntry*)entry;
 120                                         if (processor->flags & KE_SMP_PROCESSOR_ENABLED)
 121                                         {
 122                                                 kePrint("Processor (%d).\n", processor->lapicid);
 123                                                 if (processor->lapicid > max_lapic_id)
 124                                                 {
 125                                                         max_lapic_id = processor->lapicid;
 126                                                         stacks = realloc(stacks, sizeof(uintptr_t) * (max_lapic_id + 1));
 127                                                 }
 128                                                 if (processor->flags & KE_SMP_PROCESSOR_BOOTSTRAP)
 129                                                 {
 130                                                         // Add bootstrap processor to the list
 131                                                         keAddCPU(processor->lapicid);
 132                                                         bootstrap_id = processor->lapicid;
 133                                                 }
 134                                                 else
 135                                                 {
 136                                                         // Add application processor
 137                                                         uintptr_t stack = mmFindFreeKernelPages(MM_MAX_KERNEL_PAGE,
 138                                                                 MM_MIN_KERNEL_PAGE, 1, 0x1000);
 139                                                         uintptr_t paddr = mmAllocPhysicalMemory(0, 0, 0x1000);
 140                                                         mmMapKernelMemory(paddr, stack, MM_MAP_READ | MM_MAP_WRITE);
 141                                                         keAddCPU(processor->lapicid);
 142                                                         stacks[processor->lapicid] = stack + 0x1000;
 143                                                 }
 144                                         }
 145                                         entry = entry + 20;
 146                                         break;
 147                                 }
 148                                 default:
 149                                         entry = entry + 8;
 150                         }
 151                 }
 152
 153                 // Start processors
 154                 extern void *_binary_smpstart_o_start;
 155                 extern void *_binary_smpstart_o_end;
 156
 157                 // Load startup code to physical address 0x1000
 158                 uintptr_t smpstart = mmFindFreeKernelPages(MM_MAX_KERNEL_PAGE,
 159                         MM_MIN_KERNEL_PAGE, 1, 0x1000);
 160                 mmMapKernelMemory(0x1000, smpstart,
 161                         MM_MAP_READ | MM_MAP_WRITE);
 162
 163                 kePrint("start: %x, end: %x\n", &_binary_smpstart_o_start, &_binary_smpstart_o_end);
 164                 kePrint("Copying %d bytes from %x to %x\n", (uintptr_t)&_binary_smpstart_o_end - (uintptr_t)&_binary_smpstart_o_start, &_binary_smpstart_o_start, 0x2000);
 165                 memcpy((void*)smpstart, &_binary_smpstart_o_start, (uintptr_t)&_binary_smpstart_o_end - (uintptr_t)&_binary_smpstart_o_start);
 166                 kePrint("Copied memory.\n");
 167
 168                 *((volatile void**)(smpstart + 2)) = keSMPEntry;
 169                 *((volatile void**)(smpstart + 6)) = (uintptr_t*)((uintptr_t)kernel_directory - MM_KERNEL_BASE);
 170                 *((volatile void**)(smpstart + 10)) = stacks;
 171
 172                 mmMapKernelMemory(0x1000, 0x1000,
 173                         MM_MAP_READ | MM_MAP_WRITE);
 174
 175                 // Send start signal to processors
 176                 keAPICWriteInit();
 177                 // TODO: 20 ms delay
 178                 for (i = 0; i < 100000; i++)
 179                 {
 180                         keAPICRead(0x380);
 181                 }
 182                 keAPICWriteStartup(0x1000);
 183                 // TODO: Send second startup IPI after some time
 184                 //keAPICWriteStartup(0x1000);
 185
 186                 // Clean up
 187                 mmMapKernelMemory(0, smpstart, 0);
 188                 mmMapKernelMemory(0, (uint32_t)config & ~0xFFF, 0);
 189                 mmMapKernelMemory(0, (uint32_t)fps & ~0xFFF, 0);
 190                 // TODO: Wait until all procesors are running and are set up correctly
 191                 //mmMapKernelMemory(0, 0x1000, 0);
 192                 //free(stacks);
 193         }
 194 }
 195
 196 void keStartAPs(void)
 197 {
 198         start_aps = 1;
 199 }
 200
 201 static uintptr_t keFindFloatingPointerStructRange(uintptr_t addr, uintptr_t size)
 202 {
 203         // Map memory
 204         uintptr_t vaddr = mmFindFreeKernelPages(MM_MAX_KERNEL_PAGE,
 205                 MM_MIN_KERNEL_PAGE, 1, (size + 4095) & ~0xFFF);
 206         uint32_t i;
 207         for (i = 0; i < (size + 4095) / 0x1000; ++i)
 208         {
 209                 mmMapKernelMemory((addr & ~0xFFF) + i * 0x1000, vaddr + i * 0x1000, MM_MAP_READ | MM_MAP_WRITE);
 210         }
 211         vaddr += addr & 0xFFF;
 212         // Loop through possible addresses
 213         uintptr_t currentaddr = vaddr;
 214         currentaddr = ((currentaddr + 15) / 16) * 16;
 215         uintptr_t fps_phys = 0;
 216         while (currentaddr <= (vaddr + size - 16))
 217         {
 218                 FloatingPointerStruct *currentfps = (FloatingPointerStruct*)currentaddr;
 219                 // Signature
 220                 if (!memcmp(currentfps->signature, "_MP_", 4))
 221                 {
 222                         // Checksum
 223                         uint32_t i;
 224                         uint8_t checksum = 0;
 225                         for (i = 0; i < 16; i++)
 226                         {
 227                                 checksum += ((char*)currentaddr)[i];
 228                         }
 229                         if (checksum == 0)
 230                         {
 231                                 fps_phys = (uintptr_t)currentfps - vaddr + addr;
 232                                 break;
 233                         }
 234                 }
 235                 currentaddr += 16;
 236         }
 237
 238         // Unmap memory
 239         for (i = 0; i < (size + 4095) / 0x1000; ++i)
 240         {
 241                 mmMapKernelMemory(0, vaddr + i * 0x1000, 0);
 242         }
 243
 244         return fps_phys;
 245 }
 246
 247 static FloatingPointerStruct *keFindFloatingPointerStruct(void)
 248 {
 249         // Find EBDA address
 250         uintptr_t vaddr = mmFindFreeKernelPages(MM_MAX_KERNEL_PAGE,
 251                 MM_MIN_KERNEL_PAGE, 1, 0x1000);
 252         mmMapKernelMemory(0, vaddr, MM_MAP_READ | MM_MAP_WRITE);
 253
 254         /*halMapPage(kernel_directory, 0x1000, 0x0, 0x3);*/
 255         uint16_t ebdasegment = *(uint16_t*)(vaddr + 0x400 + 0x0E);
 256         mmMapKernelMemory(0, vaddr, 0);
 257         kePrint("EDBA: 0x%X\n", ((uint32_t)ebdasegment) << 4);
 258
 259         uintptr_t fps_phys = 0;
 260         if (ebdasegment)
 261         {
 262                 // Search in EDBA
 263                 fps_phys = keFindFloatingPointerStructRange(((uint32_t)ebdasegment) << 4, 1024);
 264         }
 265         else
 266         {
 267                 // Search in last kB of main memory
 268                 fps_phys = keFindFloatingPointerStructRange(0x9FC00, 1024);
 269         }
 270         if (!fps_phys)
 271         {
 272                 // Search in BIOS area
 273                 fps_phys = keFindFloatingPointerStructRange(0xE0000, 0x20000);
 274         }
 275         if (!fps_phys) return 0;
 276
 277         /*FloatingPointerStruct *fps = (FloatingPointerStruct*)halFindContinuousPages(kernel_directory, 1, 0xE0000000, 0xFFFFFFFF);
 278         halMapPage(kernel_directory, (uint32_t)fps, fps_phys & ~0xFFF, 0x3);
 279         fps = (FloatingPointerStruct*)((char*)fps + (fps_phys & 0xFFF));*/
 280         FloatingPointerStruct *fps = (void*)mmFindFreeKernelPages(MM_MAX_KERNEL_PAGE,
 281                 MM_MIN_KERNEL_PAGE, 1, 0x1000);
 282         mmMapKernelMemory(fps_phys & ~0xFFF, (uintptr_t)fps,
 283                 MM_MAP_READ | MM_MAP_WRITE);
 284         fps = (FloatingPointerStruct*)((char*)fps + (fps_phys & 0xFFF));
 285         return fps;
 286 }
 287