[STORPORT] Fix x64 build
[reactos.git] / ntoskrnl / ke / powerpc / kiinit.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ke/powerpc/kiinit.c
5 * PURPOSE: Kernel Initialization for x86 CPUs
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Art Yerkes (ayerkes@speakeasy.net)
8 */
9
10 /* INCLUDES *****************************************************************/
11
12 #include <ntoskrnl.h>
13
14 //#define NDEBUG
15 #include <debug.h>
16 #include "ppcmmu/mmu.h"
17
18 /* GLOBALS *******************************************************************/
19
20 /* Ku bit should be set, so that we get the best options for page protection */
21 #define PPC_SEG_Ku 0x40000000
22 #define PPC_SEG_Ks 0x20000000
23
24 extern LOADER_MODULE KeLoaderModules[64];
25 extern ULONG KeLoaderModuleCount;
26 extern ULONG_PTR MmFreeLdrLastKernelAddress;
27 KPRCB PrcbData[MAXIMUM_PROCESSORS];
28 /* BIOS Memory Map. Not NTLDR-compliant yet */
29 extern ULONG KeMemoryMapRangeCount;
30 extern ADDRESS_RANGE KeMemoryMap[64];
31
32 /* FUNCTIONS *****************************************************************/
33 /*
34 * Trap frame:
35 * r0 .. r32
36 * lr, ctr, srr0, srr1, dsisr
37 */
38
39 extern int syscall_start[], syscall_end, KiDecrementerTrapHandler[],
40 KiDecrementerTrapHandlerEnd;
41
42 VOID
43 NTAPI
44 KiSetupSyscallHandler(VOID)
45 {
46 paddr_t handler_target;
47 int *source;
48 for(source = syscall_start, handler_target = 0xc00;
49 source < &syscall_end;
50 source++, handler_target += sizeof(int))
51 {
52 SetPhys(handler_target, *source);
53 }
54 }
55
56 VOID
57 NTAPI
58 KiSetupDecrementerTrap(VOID)
59 {
60 paddr_t handler_target;
61 int *source;
62
63 /* Turn off EE bit while redefining dec trap */
64 _disable();
65
66 for(source = KiDecrementerTrapHandler, handler_target = 0x900;
67 source != &KiDecrementerTrapHandlerEnd;
68 source++, handler_target += sizeof(int))
69 SetPhys(handler_target, *source);
70
71 DPRINT("CurrentThread %08x IdleThread %08x\n",
72 KeGetCurrentThread(), KeGetCurrentPrcb()->IdleThread);
73
74 /* Kick decmrenter! */
75 __asm__("mtdec %0" : : "r" (0));
76
77 /* Enable interrupts! */
78 _enable();
79 }
80
81 VOID
82 NTAPI
83 KiInitializePcr(IN ULONG ProcessorNumber,
84 IN PKIPCR Pcr,
85 IN PKTHREAD IdleThread,
86 IN PVOID DpcStack)
87 {
88 Pcr->MajorVersion = PCR_MAJOR_VERSION;
89 Pcr->MinorVersion = PCR_MINOR_VERSION;
90 Pcr->CurrentIrql = PASSIVE_LEVEL;
91 Pcr->PrcbData = &PrcbData[ProcessorNumber];
92 Pcr->PrcbData->MajorVersion = PRCB_MAJOR_VERSION;
93 Pcr->PrcbData->MinorVersion = 0;
94 Pcr->PrcbData->Number = 0; /* UP for now */
95 Pcr->PrcbData->SetMember = 1;
96 #if DBG
97 Pcr->PrcbData->BuildType = PRCB_BUILD_DEBUG;
98 #else
99 Pcr->PrcbData->BuildType = 0;
100 #endif
101 Pcr->PrcbData->DpcStack = DpcStack;
102 KeGetPcr()->Prcb = Pcr->PrcbData;
103 KiProcessorBlock[ProcessorNumber] = Pcr->PrcbData;
104 }
105
106 extern ULONG KiGetFeatureBits();
107 extern VOID KiSetProcessorType();
108 extern VOID KiGetCacheInformation();
109
110 VOID
111 NTAPI
112 KiInitializeKernel(IN PKPROCESS InitProcess,
113 IN PKTHREAD InitThread,
114 IN PVOID IdleStack,
115 IN PKPRCB Prcb,
116 IN CCHAR Number,
117 IN PLOADER_PARAMETER_BLOCK LoaderBlock)
118 {
119 ULONG FeatureBits;
120 LARGE_INTEGER PageDirectory;
121 PVOID DpcStack;
122
123 /* Detect and set the CPU Type */
124 KiSetProcessorType();
125
126 /* Initialize the Power Management Support for this PRCB */
127 PoInitializePrcb(Prcb);
128
129 /* Get the processor features for the CPU */
130 FeatureBits = KiGetFeatureBits();
131
132 /* Save feature bits */
133 Prcb->FeatureBits = FeatureBits;
134
135 /* Get cache line information for this CPU */
136 KiGetCacheInformation();
137
138 /* Initialize spinlocks and DPC data */
139 KiInitSpinLocks(Prcb, Number);
140
141 /* Check if this is the Boot CPU */
142 if (!Number)
143 {
144 /* Set Node Data */
145 KeNodeBlock[0] = &KiNode0;
146 Prcb->ParentNode = KeNodeBlock[0];
147 KeNodeBlock[0]->ProcessorMask = Prcb->SetMember;
148
149 /* Set boot-level flags */
150 KeProcessorArchitecture = 0;
151 KeProcessorLevel = (USHORT)Prcb->CpuType;
152 KeFeatureBits = FeatureBits;
153
154 /* Set the current MP Master KPRCB to the Boot PRCB */
155 Prcb->MultiThreadSetMaster = Prcb;
156
157 /* Lower to APC_LEVEL */
158 KeLowerIrql(APC_LEVEL);
159
160 /* Initialize portable parts of the OS */
161 KiInitSystem();
162
163 /* Initialize the Idle Process and the Process Listhead */
164 InitializeListHead(&KiProcessListHead);
165 PageDirectory.QuadPart = 0;
166 KeInitializeProcess(InitProcess,
167 0,
168 0xFFFFFFFF,
169 &PageDirectory,
170 TRUE);
171 InitProcess->QuantumReset = MAXCHAR;
172 }
173 else
174 {
175 /* FIXME */
176 DPRINT1("SMP Boot support not yet present\n");
177 }
178
179 /* Setup the Idle Thread */
180 KeInitializeThread(InitProcess,
181 InitThread,
182 NULL,
183 NULL,
184 NULL,
185 NULL,
186 NULL,
187 IdleStack);
188 InitThread->NextProcessor = Number;
189 InitThread->Priority = HIGH_PRIORITY;
190 InitThread->State = Running;
191 InitThread->Affinity = 1 << Number;
192 InitThread->WaitIrql = DISPATCH_LEVEL;
193 InitProcess->ActiveProcessors = 1 << Number;
194
195 /* HACK for MmUpdatePageDir */
196 ((PETHREAD)InitThread)->ThreadsProcess = (PEPROCESS)InitProcess;
197
198 /* Set up the thread-related fields in the PRCB */
199 Prcb->CurrentThread = InitThread;
200 Prcb->NextThread = NULL;
201 Prcb->IdleThread = InitThread;
202
203 /* Initialize Kernel Memory Address Space */
204 MmInit1(MmFreeLdrFirstKrnlPhysAddr,
205 MmFreeLdrLastKrnlPhysAddr,
206 MmFreeLdrLastKernelAddress,
207 KeMemoryMap,
208 KeMemoryMapRangeCount,
209 4096);
210
211 /* Initialize the Kernel Executive */
212 ExpInitializeExecutive(0, LoaderBlock);
213
214 /* Only do this on the boot CPU */
215 if (!Number)
216 {
217 /* Calculate the time reciprocal */
218 KiTimeIncrementReciprocal =
219 KiComputeReciprocal(KeMaximumIncrement,
220 &KiTimeIncrementShiftCount);
221
222 /* Update DPC Values in case they got updated by the executive */
223 Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
224 Prcb->MinimumDpcRate = KiMinimumDpcRate;
225 Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
226
227 /* Allocate the DPC Stack */
228 DpcStack = MmCreateKernelStack(FALSE, 0);
229 if (!DpcStack) KeBugCheckEx(NO_PAGES_AVAILABLE, 1, 0, 0, 0);
230 Prcb->DpcStack = DpcStack;
231 }
232
233 KfRaiseIrql(DISPATCH_LEVEL);
234
235 KeSetPriorityThread(InitThread, 0);
236 /* Setup decrementer exception */
237 KiSetupDecrementerTrap();
238
239 KfLowerIrql(PASSIVE_LEVEL);
240
241 /* Should not return */
242 while(1)
243 {
244 NtYieldExecution();
245 }
246 }
247
248 extern int KiPageFaultTrap();
249 KTRAP_FRAME KiInitialTrapFrame;
250
251 /* Use this for early boot additions to the page table */
252 VOID
253 NTAPI
254 KiSystemStartupReal(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
255 {
256 ULONG Cpu;
257 ppc_map_info_t info[4];
258 PKIPCR Pcr = (PKIPCR)KPCR_BASE;
259 PKPRCB Prcb;
260
261 __asm__("mr 13,%0" : : "r" (KPCR_BASE));
262
263 /* Set the page fault handler to the kernel */
264 MmuSetTrapHandler(3,KiPageFaultTrap);
265 MmuSetTrapHandler(4,KiPageFaultTrap);
266
267 // Make 0xf... special
268 MmuAllocVsid(2, 0x8000);
269 MmuSetVsid(15,16,2);
270
271 /* Get the current CPU */
272 Cpu = KeNumberProcessors;
273 if (!Cpu)
274 {
275 /* We'll allocate a page from the end of the kernel area for KPCR. This code will probably
276 * change when we get SMP support.
277 */
278 info[0].phys = 0;
279 info[0].proc = 2;
280 info[0].addr = (vaddr_t)Pcr;
281 info[0].flags = MMU_KRW_UR;
282 info[1].phys = 0;
283 info[1].proc = 2;
284 info[1].addr = ((vaddr_t)Pcr) + (1 << PAGE_SHIFT);
285 info[1].flags = MMU_KRW_UR;
286 info[2].phys = 0;
287 info[2].proc = 2;
288 info[2].addr = (vaddr_t)KI_USER_SHARED_DATA;
289 info[2].flags = MMU_KRW_UR;
290 info[3].phys = 0;
291 info[3].proc = 2;
292 info[3].addr = (vaddr_t)KIP0PCRADDRESS;
293 info[3].flags = MMU_KRW_UR;
294 MmuMapPage(info, 4);
295 }
296
297 /* Skip initial setup if this isn't the Boot CPU */
298 if (Cpu) goto AppCpuInit;
299
300 /* Initialize the PCR */
301 RtlZeroMemory(Pcr, PAGE_SIZE);
302 KiInitializePcr(Cpu,
303 Pcr,
304 &KiInitialThread.Tcb,
305 KiDoubleFaultStack);
306
307 /* Set us as the current process */
308 KiInitialThread.Tcb.ApcState.Process = &KiInitialProcess.Pcb;
309 KiInitialThread.Tcb.TrapFrame = &KiInitialTrapFrame;
310
311 /* Setup CPU-related fields */
312 AppCpuInit:
313 Pcr->Number = Cpu;
314 Pcr->SetMember = 1 << Cpu;
315 Prcb = KeGetCurrentPrcb();
316 Prcb->SetMember = 1 << Cpu;
317
318 /* Initialize the Processor with HAL */
319 HalInitializeProcessor(Cpu, LoaderBlock);
320
321 /* Set active processors */
322 KeActiveProcessors |= Pcr->SetMember;
323 KeNumberProcessors++;
324
325 /* Initialize the Debugger for the Boot CPU */
326 if (!Cpu) KdInitSystem (0, LoaderBlock);
327
328 /* Check for break-in */
329 if (KdPollBreakIn())
330 {
331 DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C);
332 }
333
334 /* Raise to HIGH_LEVEL */
335 KfRaiseIrql(HIGH_LEVEL);
336
337 /* Call main kernel intialization */
338 KiInitializeKernel(&KiInitialProcess.Pcb,
339 &KiInitialThread.Tcb,
340 P0BootStack,
341 Prcb,
342 Cpu,
343 (PVOID)LoaderBlock);
344 }
345
346 VOID
347 NTAPI
348 KiInitMachineDependent(VOID)
349 {
350 }
351
352 void abort(VOID)
353 {
354 KeBugCheck(KMODE_EXCEPTION_NOT_HANDLED);
355 while(1);
356 }