ReactOS  0.4.13-dev-257-gfabbd7c
osl.c
Go to the documentation of this file.
1 /*******************************************************************************
2 * *
3 * ACPI Component Architecture Operating System Layer (OSL) for ReactOS *
4 * *
5 *******************************************************************************/
6 
7 #include "precomp.h"
8 
9 #include <pseh/pseh2.h>
10 
11 #define NDEBUG
12 #include <debug.h>
13 
18 static ULONG AcpiIrqNumber = 0;
19 
22 {
23  DPRINT("AcpiOsInitialize called\n");
24 
25 #ifndef NDEBUG
26  /* Verboseness level of the acpica core */
27  AcpiDbgLevel = 0x00FFFFFF;
28  AcpiDbgLayer = 0xFFFFFFFF;
29 #endif
30 
31  return AE_OK;
32 }
33 
36 {
37  DPRINT("AcpiOsTerminate() called\n");
38 
39  return AE_OK;
40 }
41 
42 ACPI_PHYSICAL_ADDRESS
44  void)
45 {
46  ACPI_PHYSICAL_ADDRESS pa = 0;
47 
48  DPRINT("AcpiOsGetRootPointer\n");
49 
51  return pa;
52 }
53 
56  const ACPI_PREDEFINED_NAMES *PredefinedObject,
57  ACPI_STRING *NewValue)
58 {
59  if (!PredefinedObject || !NewValue)
60  {
61  DPRINT1("Invalid parameter\n");
62  return AE_BAD_PARAMETER;
63  }
64 
65  /* No override */
66  *NewValue = NULL;
67 
68  return AE_OK;
69 }
70 
73  ACPI_TABLE_HEADER *ExistingTable,
74  ACPI_TABLE_HEADER **NewTable)
75 {
76  if (!ExistingTable || !NewTable)
77  {
78  DPRINT1("Invalid parameter\n");
79  return AE_BAD_PARAMETER;
80  }
81 
82  /* No override */
83  *NewTable = NULL;
84 
85  return AE_OK;
86 }
87 
90  ACPI_TABLE_HEADER *ExistingTable,
91  ACPI_PHYSICAL_ADDRESS *NewAddress,
92  UINT32 *NewTableLength)
93 {
94  if (!ExistingTable || !NewAddress || !NewTableLength)
95  {
96  DPRINT1("Invalid parameter\n");
97  return AE_BAD_PARAMETER;
98  }
99 
100  /* No override */
101  *NewAddress = 0;
102  *NewTableLength = 0;
103 
104  return AE_OK;
105 }
106 
107 void *
109  ACPI_PHYSICAL_ADDRESS phys,
110  ACPI_SIZE length)
111 {
113  PVOID Ptr;
114 
115  DPRINT("AcpiOsMapMemory(phys 0x%p size 0x%X)\n", phys, length);
116 
117  Address.QuadPart = (ULONG)phys;
119  if (!Ptr)
120  {
121  DPRINT1("Mapping failed\n");
122  }
123 
124  return Ptr;
125 }
126 
127 void
129  void *virt,
130  ACPI_SIZE length)
131 {
132  DPRINT("AcpiOsMapMemory(phys 0x%p size 0x%X)\n", virt, length);
133 
134  ASSERT(virt);
135 
136  MmUnmapIoSpace(virt, length);
137 }
138 
141  void *LogicalAddress,
142  ACPI_PHYSICAL_ADDRESS *PhysicalAddress)
143 {
144  PHYSICAL_ADDRESS PhysAddr;
145 
146  if (!LogicalAddress || !PhysicalAddress)
147  {
148  DPRINT1("Bad parameter\n");
149  return AE_BAD_PARAMETER;
150  }
151 
152  PhysAddr = MmGetPhysicalAddress(LogicalAddress);
153 
154  *PhysicalAddress = (ACPI_PHYSICAL_ADDRESS)PhysAddr.QuadPart;
155 
156  return AE_OK;
157 }
158 
159 void *
160 AcpiOsAllocate (ACPI_SIZE size)
161 {
162  DPRINT("AcpiOsAllocate size %d\n",size);
163  return ExAllocatePoolWithTag(NonPagedPool, size, 'ipcA');
164 }
165 
166 void
168 {
169  if (!ptr)
170  DPRINT1("Attempt to free null pointer!!!\n");
171  ExFreePoolWithTag(ptr, 'ipcA');
172 }
173 
174 BOOLEAN
176  void *Memory,
177  ACPI_SIZE Length)
178 {
179  BOOLEAN Ret = FALSE;
180 
181  _SEH2_TRY
182  {
183  ProbeForRead(Memory, Length, sizeof(UCHAR));
184  Ret = TRUE;
185  }
187  {
188  Ret = FALSE;
189  }
190  _SEH2_END;
191 
192  return Ret;
193 }
194 
195 BOOLEAN
197  void *Memory,
198  ACPI_SIZE Length)
199 {
200  BOOLEAN Ret = FALSE;
201 
202  _SEH2_TRY
203  {
204  ProbeForWrite(Memory, Length, sizeof(UCHAR));
205  Ret = TRUE;
206  }
208  {
209  Ret = FALSE;
210  }
211  _SEH2_END;
212 
213  return Ret;
214 }
215 
218 {
219  /* Thread ID must be non-zero */
220  return (ULONG_PTR)PsGetCurrentThreadId() + 1;
221 }
222 
227  void *Context)
228 {
229  HANDLE ThreadHandle;
232 
233  DPRINT("AcpiOsExecute\n");
234 
236  NULL,
238  NULL,
239  NULL);
240 
241  Status = PsCreateSystemThread(&ThreadHandle,
244  NULL,
245  NULL,
247  Context);
248  if (!NT_SUCCESS(Status))
249  return AE_ERROR;
250 
251  ZwClose(ThreadHandle);
252 
253  return AE_OK;
254 }
255 
256 void
257 AcpiOsSleep (UINT64 milliseconds)
258 {
259  DPRINT("AcpiOsSleep %d\n", milliseconds);
260  KeStallExecutionProcessor(milliseconds*1000);
261 }
262 
263 void
264 AcpiOsStall (UINT32 microseconds)
265 {
266  DPRINT("AcpiOsStall %d\n",microseconds);
267  KeStallExecutionProcessor(microseconds);
268 }
269 
272  ACPI_MUTEX *OutHandle)
273 {
275 
276  if (!OutHandle)
277  {
278  DPRINT1("Bad parameter\n");
279  return AE_BAD_PARAMETER;
280  }
281 
283  if (!Mutex) return AE_NO_MEMORY;
284 
286 
287  *OutHandle = (ACPI_MUTEX)Mutex;
288 
289  return AE_OK;
290 }
291 
292 void
295 {
296  if (!Handle)
297  {
298  DPRINT1("Bad parameter\n");
299  return;
300  }
301 
302  ExFreePoolWithTag(Handle, 'LpcA');
303 }
304 
308  UINT16 Timeout)
309 {
310  if (!Handle)
311  {
312  DPRINT1("Bad parameter\n");
313  return AE_BAD_PARAMETER;
314  }
315 
316  /* Check what the caller wants us to do */
317  if (Timeout == ACPI_DO_NOT_WAIT)
318  {
319  /* Try to acquire without waiting */
321  return AE_TIME;
322  }
323  else
324  {
325  /* Block until we get it */
327  }
328 
329  return AE_OK;
330 }
331 
332 void
335 {
336  if (!Handle)
337  {
338  DPRINT1("Bad parameter\n");
339  return;
340  }
341 
343 }
344 
345 typedef struct _ACPI_SEM {
349 } ACPI_SEM, *PACPI_SEM;
350 
353  UINT32 MaxUnits,
354  UINT32 InitialUnits,
355  ACPI_SEMAPHORE *OutHandle)
356 {
357  PACPI_SEM Sem;
358 
359  if (!OutHandle)
360  {
361  DPRINT1("Bad parameter\n");
362  return AE_BAD_PARAMETER;
363  }
364 
365  Sem = ExAllocatePoolWithTag(NonPagedPool, sizeof(ACPI_SEM), 'LpcA');
366  if (!Sem) return AE_NO_MEMORY;
367 
368  Sem->CurrentUnits = InitialUnits;
370  KeInitializeSpinLock(&Sem->Lock);
371 
372  *OutHandle = (ACPI_SEMAPHORE)Sem;
373 
374  return AE_OK;
375 }
376 
380 {
381  if (!Handle)
382  {
383  DPRINT1("Bad parameter\n");
384  return AE_BAD_PARAMETER;
385  }
386 
387  ExFreePoolWithTag(Handle, 'LpcA');
388 
389  return AE_OK;
390 }
391 
395  UINT32 Units,
396  UINT16 Timeout)
397 {
398  PACPI_SEM Sem = Handle;
399  KIRQL OldIrql;
400 
401  if (!Handle)
402  {
403  DPRINT1("Bad parameter\n");
404  return AE_BAD_PARAMETER;
405  }
406 
407  KeAcquireSpinLock(&Sem->Lock, &OldIrql);
408 
409  /* Make sure we can wait if we have fewer units than we need */
410  if ((Timeout == ACPI_DO_NOT_WAIT) && (Sem->CurrentUnits < Units))
411  {
412  /* We can't so we must bail now */
414  return AE_TIME;
415  }
416 
417  /* Time to block until we get enough units */
418  while (Sem->CurrentUnits < Units)
419  {
422  Executive,
423  KernelMode,
424  FALSE,
425  NULL);
426  KeAcquireSpinLock(&Sem->Lock, &OldIrql);
427  }
428 
429  Sem->CurrentUnits -= Units;
430 
431  if (Sem->CurrentUnits != 0) KeSetEvent(&Sem->Event, IO_NO_INCREMENT, FALSE);
432 
434 
435  return AE_OK;
436 }
437 
441  UINT32 Units)
442 {
443  PACPI_SEM Sem = Handle;
444  KIRQL OldIrql;
445 
446  if (!Handle)
447  {
448  DPRINT1("Bad parameter\n");
449  return AE_BAD_PARAMETER;
450  }
451 
452  KeAcquireSpinLock(&Sem->Lock, &OldIrql);
453 
454  Sem->CurrentUnits += Units;
456 
458 
459  return AE_OK;
460 }
461 
464  ACPI_SPINLOCK *OutHandle)
465 {
467 
468  if (!OutHandle)
469  {
470  DPRINT1("Bad parameter\n");
471  return AE_BAD_PARAMETER;
472  }
473 
475  if (!SpinLock) return AE_NO_MEMORY;
476 
478 
479  *OutHandle = (ACPI_SPINLOCK)SpinLock;
480 
481  return AE_OK;
482 }
483 
484 void
487 {
488  if (!Handle)
489  {
490  DPRINT1("Bad parameter\n");
491  return;
492  }
493 
494  ExFreePoolWithTag(Handle, 'LpcA');
495 }
496 
500 {
501  KIRQL OldIrql;
502 
504  {
506  }
507  else
508  {
510  }
511 
512  return (ACPI_CPU_FLAGS)OldIrql;
513 }
514 
515 void
519 {
521 
522  if (OldIrql >= DISPATCH_LEVEL)
523  {
525  }
526  else
527  {
529  }
530 }
531 
534  PKINTERRUPT Interrupt,
536 {
537  INT32 Status;
538 
539  Status = (*AcpiIrqHandler)(AcpiIrqContext);
540 
542  return TRUE;
543  else
544  return FALSE;
545 }
546 
547 UINT32
549  UINT32 InterruptNumber,
551  void *Context)
552 {
553  ULONG Vector;
554  KIRQL DIrql;
557 
559  {
560  DPRINT1("Reregister interrupt attempt failed\n");
561  return AE_ALREADY_EXISTS;
562  }
563 
564  if (!ServiceRoutine)
565  {
566  DPRINT1("Bad parameter\n");
567  return AE_BAD_PARAMETER;
568  }
569 
570  DPRINT("AcpiOsInstallInterruptHandler()\n");
572  Internal,
573  0,
574  InterruptNumber,
575  InterruptNumber,
576  &DIrql,
577  &Affinity);
578 
579  AcpiIrqNumber = InterruptNumber;
583 
585  &AcpiInterrupt,
586  OslIsrStub,
587  NULL,
588  NULL,
589  Vector,
590  DIrql,
591  DIrql,
593  TRUE,
594  Affinity,
595  FALSE);
596 
597  if (!NT_SUCCESS(Status))
598  {
599  DPRINT("Could not connect to interrupt %d\n", Vector);
600  return AE_ERROR;
601  }
602  return AE_OK;
603 }
604 
607  UINT32 InterruptNumber,
609 {
610  DPRINT("AcpiOsRemoveInterruptHandler()\n");
611 
612  if (!ServiceRoutine)
613  {
614  DPRINT1("Bad parameter\n");
615  return AE_BAD_PARAMETER;
616  }
617 
619  {
623  }
624  else
625  {
626  DPRINT1("Trying to remove non-existing interrupt handler\n");
627  return AE_NOT_EXIST;
628  }
629 
630  return AE_OK;
631 }
632 
635  ACPI_PHYSICAL_ADDRESS Address,
636  UINT64 *Value,
637  UINT32 Width)
638 {
639  DPRINT("AcpiOsReadMemory %p\n", Address);
640  switch (Width)
641  {
642  case 8:
643  *Value = (*(PUCHAR)(ULONG_PTR)Address);
644  break;
645 
646  case 16:
647  *Value = (*(PUSHORT)(ULONG_PTR)Address);
648  break;
649 
650  case 32:
651  *Value = (*(PULONG)(ULONG_PTR)Address);
652  break;
653 
654  case 64:
656  break;
657 
658  default:
659  DPRINT1("AcpiOsReadMemory got bad width: %d\n",Width);
660  return (AE_BAD_PARAMETER);
661  break;
662  }
663  return (AE_OK);
664 }
665 
668  ACPI_PHYSICAL_ADDRESS Address,
669  UINT64 Value,
670  UINT32 Width)
671 {
672  DPRINT("AcpiOsWriteMemory %p\n", Address);
673  switch (Width)
674  {
675  case 8:
677  break;
678 
679  case 16:
681  break;
682 
683  case 32:
685  break;
686 
687  case 64:
689  break;
690 
691  default:
692  DPRINT1("AcpiOsWriteMemory got bad width: %d\n",Width);
693  return (AE_BAD_PARAMETER);
694  break;
695  }
696 
697  return (AE_OK);
698 }
699 
702  ACPI_IO_ADDRESS Address,
703  UINT32 *Value,
704  UINT32 Width)
705 {
706  DPRINT("AcpiOsReadPort %p, width %d\n",Address,Width);
707 
708  switch (Width)
709  {
710  case 8:
712  break;
713 
714  case 16:
716  break;
717 
718  case 32:
720  break;
721 
722  default:
723  DPRINT1("AcpiOsReadPort got bad width: %d\n",Width);
724  return (AE_BAD_PARAMETER);
725  break;
726  }
727  return (AE_OK);
728 }
729 
732  ACPI_IO_ADDRESS Address,
733  UINT32 Value,
734  UINT32 Width)
735 {
736  DPRINT("AcpiOsWritePort %p, width %d\n",Address,Width);
737  switch (Width)
738  {
739  case 8:
741  break;
742 
743  case 16:
745  break;
746 
747  case 32:
749  break;
750 
751  default:
752  DPRINT1("AcpiOsWritePort got bad width: %d\n",Width);
753  return (AE_BAD_PARAMETER);
754  break;
755  }
756  return (AE_OK);
757 }
758 
759 BOOLEAN
761 {
762  UINT32 ReadLength;
763  PCI_COMMON_CONFIG PciConfig;
764 
765  /* Detect device presence by reading the PCI configuration space */
766 
768  BusNumber,
769  SlotNumber,
770  &PciConfig,
771  0,
772  sizeof(PciConfig));
773  if (ReadLength == 0)
774  {
775  DPRINT("PCI device is not present\n");
776  return FALSE;
777  }
778 
779  ASSERT(ReadLength >= 2);
780 
781  if (PciConfig.VendorID == PCI_INVALID_VENDORID)
782  {
783  DPRINT("Invalid vendor ID in PCI configuration space\n");
784  return FALSE;
785  }
786 
787  DPRINT("PCI device is present\n");
788 
789  return TRUE;
790 }
791 
794  ACPI_PCI_ID *PciId,
795  UINT32 Reg,
796  UINT64 *Value,
797  UINT32 Width)
798 {
800 
801  slot.u.AsULONG = 0;
802  slot.u.bits.DeviceNumber = PciId->Device;
803  slot.u.bits.FunctionNumber = PciId->Function;
804 
805  DPRINT("AcpiOsReadPciConfiguration, slot=0x%X, func=0x%X\n", slot.u.AsULONG, Reg);
806 
807  if (!OslIsPciDevicePresent(PciId->Bus, slot.u.AsULONG))
808  return AE_NOT_FOUND;
809 
810  /* Width is in BITS */
812  PciId->Bus,
813  slot.u.AsULONG,
814  Value,
815  Reg,
816  (Width >> 3));
817 
818  return AE_OK;
819 }
820 
823  ACPI_PCI_ID *PciId,
824  UINT32 Reg,
825  UINT64 Value,
826  UINT32 Width)
827 {
828  ULONG buf = Value;
830 
831  slot.u.AsULONG = 0;
832  slot.u.bits.DeviceNumber = PciId->Device;
833  slot.u.bits.FunctionNumber = PciId->Function;
834 
835  DPRINT("AcpiOsWritePciConfiguration, slot=0x%x\n", slot.u.AsULONG);
836  if (!OslIsPciDevicePresent(PciId->Bus, slot.u.AsULONG))
837  return AE_NOT_FOUND;
838 
839  /* Width is in BITS */
841  PciId->Bus,
842  slot.u.AsULONG,
843  &buf,
844  Reg,
845  (Width >> 3));
846 
847  return AE_OK;
848 }
849 
852  const char *Fmt,
853  ...)
854 {
855  va_list Args;
856  va_start (Args, Fmt);
857 
858  AcpiOsVprintf (Fmt, Args);
859 
860  va_end (Args);
861  return;
862 }
863 
864 void
866  const char *Fmt,
867  va_list Args)
868 {
869 #ifndef NDEBUG
870  vDbgPrintEx (-1, DPFLTR_ERROR_LEVEL, Fmt, Args);
871 #endif
872  return;
873 }
874 
875 void
877  void *Destination)
878 {
879  /* No-op */
880  DPRINT1("Output redirection not supported\n");
881 }
882 
883 UINT64
885  void)
886 {
887  LARGE_INTEGER CurrentTime;
888 
889  KeQuerySystemTime(&CurrentTime);
890  return CurrentTime.QuadPart;
891 }
892 
893 void
895 {
896  /*
897  * Wait for all asynchronous events to complete.
898  * This implementation does nothing.
899  */
900  return;
901 }
902 
906  void *Info)
907 {
908  ACPI_SIGNAL_FATAL_INFO *FatalInfo = Info;
909 
910  switch (Function)
911  {
912  case ACPI_SIGNAL_FATAL:
913  if (Info)
914  DPRINT1 ("AcpiOsBreakpoint: %d %d %d ****\n", FatalInfo->Type, FatalInfo->Code, FatalInfo->Argument);
915  else
916  DPRINT1 ("AcpiOsBreakpoint ****\n");
917  break;
919  if (Info)
920  DPRINT1 ("AcpiOsBreakpoint: %s ****\n", Info);
921  else
922  DPRINT1 ("AcpiOsBreakpoint ****\n");
923  break;
924  }
925 
926  ASSERT(FALSE);
927 
928  return (AE_OK);
929 }
930 
933  UINT8 SleepState,
934  UINT32 RegaValue,
935  UINT32 RegbValue)
936 {
937  DPRINT1("Entering sleep state S%u.\n", SleepState);
938  return AE_OK;
939 }
940 
943  char *Buffer,
945  UINT32 *BytesRead)
946 {
947  DPRINT1("File reading not supported\n");
948  return AE_ERROR;
949 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
static ACPI_OSD_HANDLER AcpiIrqHandler
Definition: osl.c:16
static BYTE Memory[0x20]
Definition: ps2.c:54
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
ACPI_STATUS AcpiOsGetPhysicalAddress(void *LogicalAddress, ACPI_PHYSICAL_ADDRESS *PhysicalAddress)
Definition: osl.c:140
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
void AcpiOsStall(UINT32 microseconds)
Definition: osl.c:264
#define TRUE
Definition: types.h:120
ACPI_STATUS AcpiOsRemoveInterruptHandler(UINT32 InterruptNumber, ACPI_OSD_HANDLER ServiceRoutine)
Definition: osl.c:606
Type
Definition: Type.h:6
ACPI_STATUS AcpiOsTerminate(void)
Definition: osl.c:35
VOID NTAPI WRITE_PORT_USHORT(IN PUSHORT Port, IN USHORT Value)
Definition: portio.c:115
#define AE_NO_MEMORY
Definition: acexcep.h:112
NTHALAPI ULONG NTAPI HalGetInterruptVector(INTERFACE_TYPE, ULONG, ULONG, ULONG, PKIRQL, PKAFFINITY)
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
struct _slot slot
Definition: vfat.h:196
static ULONG AcpiIrqNumber
Definition: osl.c:18
ACPI_STATUS AcpiOsEnterSleep(UINT8 SleepState, UINT32 RegaValue, UINT32 RegbValue)
Definition: osl.c:932
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
BOOLEAN NTAPI OslIsrStub(PKINTERRUPT Interrupt, PVOID ServiceContext)
Definition: osl.c:533
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
UINT16 Bus
Definition: actypes.h:1327
BOOLEAN OslIsPciDevicePresent(ULONG BusNumber, ULONG SlotNumber)
Definition: osl.c:760
unsigned char * PUCHAR
Definition: retypes.h:3
ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
Definition: osl.c:498
UCHAR NTAPI READ_PORT_UCHAR(PUCHAR Address)
Definition: mach.c:535
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
VOID NTAPI KeAcquireSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:192
LONG NTSTATUS
Definition: precomp.h:26
KEVENT Event
Definition: osl.c:347
UINT32 AcpiOsInstallInterruptHandler(UINT32 InterruptNumber, ACPI_OSD_HANDLER ServiceRoutine, void *Context)
Definition: osl.c:548
ULONG NTAPI READ_PORT_ULONG(IN PULONG Port)
Definition: portio.c:70
ACPI_STATUS AcpiOsAcquireMutex(ACPI_MUTEX Handle, UINT16 Timeout)
Definition: osl.c:306
#define ACPI_SEMAPHORE
Definition: actypes.h:287
#define ACPI_CPU_FLAGS
Definition: actypes.h:252
ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)
Definition: osl.c:378
UINT16 Device
Definition: actypes.h:1328
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
PVOID NTAPI MmMapIoSpace(IN PHYSICAL_ADDRESS PhysicalAddress, IN SIZE_T NumberOfBytes, IN MEMORY_CACHING_TYPE CacheType)
Definition: iosup.c:47
UINT32 ACPI_STATUS
Definition: actypes.h:460
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
#define AE_TIME
Definition: acexcep.h:125
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
VOID FASTCALL ExReleaseFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:31
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
Definition: Mutex.h:15
struct TraceInfo Info
_SEH2_TRY
Definition: create.c:4250
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK SpinLock
Definition: iofuncs.h:798
uint32_t ULONG_PTR
Definition: typedefs.h:63
static PKINTERRUPT AcpiInterrupt
Definition: osl.c:14
#define ACPI_SPINLOCK
Definition: actypes.h:283
UCHAR KIRQL
Definition: env_spec_w32.h:591
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
VOID NTAPI WRITE_PORT_ULONG(IN PULONG Port, IN ULONG Value)
Definition: portio.c:123
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define va_end(ap)
Definition: acmsvcex.h:90
UINT32(ACPI_SYSTEM_XFACE * ACPI_OSD_HANDLER)(void *Context)
Definition: actypes.h:1111
KSTART_ROUTINE * PKSTART_ROUTINE
Definition: ketypes.h:487
static LPOVERLAPPED_COMPLETION_ROUTINE Function
Definition: sync.c:684
unsigned int UINT32
void AcpiOsWaitEventsComplete(void)
Definition: osl.c:894
char * ACPI_STRING
Definition: actypes.h:462
void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
Definition: osl.c:516
NTSTATUS NTAPI IoConnectInterrupt(OUT PKINTERRUPT *InterruptObject, IN PKSERVICE_ROUTINE ServiceRoutine, IN PVOID ServiceContext, IN PKSPIN_LOCK SpinLock, IN ULONG Vector, IN KIRQL Irql, IN KIRQL SynchronizeIrql, IN KINTERRUPT_MODE InterruptMode, IN BOOLEAN ShareVector, IN KAFFINITY ProcessorEnableMask, IN BOOLEAN FloatingSave)
Definition: irq.c:22
_In_ ULONG BufferLength
Definition: usbdlib.h:225
ACPI_STATUS ACPI_INIT_FUNCTION AcpiFindRootPointer(ACPI_PHYSICAL_ADDRESS *TableAddress)
Definition: tbxfroot.c:160
ACPI_STATUS AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 Value, UINT32 Width)
Definition: osl.c:667
static PVOID ptr
Definition: dispmode.c:27
ACPI_STATUS AcpiOsSignalSemaphore(ACPI_SEMAPHORE Handle, UINT32 Units)
Definition: osl.c:439
UINT64 AcpiOsGetTimer(void)
Definition: osl.c:884
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
static WCHAR Address[46]
Definition: ping.c:68
VOID NTAPI IoDisconnectInterrupt(PKINTERRUPT InterruptObject)
Definition: irq.c:140
ACPI_STATUS AcpiOsSignal(UINT32 Function, void *Info)
Definition: osl.c:904
char * va_list
Definition: acmsvcex.h:78
void DPRINT(...)
Definition: polytest.cpp:61
PsGetCurrentThreadId
Definition: CrNtStubs.h:7
char ** Args
Definition: acdebug.h:343
Definition: bufpool.h:45
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG BusNumber
Definition: halfuncs.h:156
ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, void *Context)
Definition: osl.c:224
FAST_MUTEX
Definition: extypes.h:17
ACPI_PHYSICAL_ADDRESS AcpiOsGetRootPointer(void)
Definition: osl.c:43
Definition: osl.c:345
_In_ HANDLE Handle
Definition: extypes.h:390
#define ACPI_INTERNAL_VAR_XFACE
Definition: acenv.h:323
void AcpiOsSleep(UINT64 milliseconds)
Definition: osl.c:257
#define ACPI_DO_NOT_WAIT
Definition: actypes.h:502
ACPI_STATUS AcpiOsPhysicalTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_PHYSICAL_ADDRESS *NewAddress, UINT32 *NewTableLength)
Definition: osl.c:89
GLsizeiptr size
Definition: glext.h:5919
#define ACPI_INTERRUPT_HANDLED
Definition: actypes.h:1239
#define PCI_INVALID_VENDORID
Definition: iotypes.h:3244
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
ACPI_STATUS AcpiOsGetLine(char *Buffer, UINT32 BufferLength, UINT32 *BytesRead)
Definition: osl.c:942
ACPI_STATUS AcpiOsInitialize(void)
Definition: osl.c:21
#define AE_ALREADY_EXISTS
Definition: acexcep.h:115
VOID NTAPI KeReleaseSpinLockFromDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:215
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
BOOLEAN FASTCALL ExTryToAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:39
_In_ ULONG _In_ ULONG _In_ ULONG _Out_ PKIRQL _Out_ PKAFFINITY Affinity
Definition: halfuncs.h:170
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2875
NTSYSAPI ULONG NTAPI vDbgPrintEx(_In_ ULONG ComponentId, _In_ ULONG Level, _In_z_ PCCH Format, _In_ va_list ap)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
struct _ACPI_SEM ACPI_SEM
#define AE_NOT_FOUND
Definition: acexcep.h:113
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID ServiceContext
Definition: iofuncs.h:798
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
void AcpiOsUnmapMemory(void *virt, ACPI_SIZE length)
Definition: osl.c:128
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG _In_ ULONG SlotNumber
Definition: halfuncs.h:156
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS PhysicalAddress
Definition: iotypes.h:1060
unsigned char UCHAR
Definition: xmlstorage.h:181
UINT32 CurrentUnits
Definition: osl.c:346
ULONG NTAPI HalGetBusDataByOffset(IN BUS_DATA_TYPE BusDataType, IN ULONG BusNumber, IN ULONG SlotNumber, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
Definition: bus.c:73
ACPI_EXECUTE_TYPE
Definition: acpiosxf.h:55
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define AE_NOT_EXIST
Definition: acexcep.h:114
ACPI_STATUS AcpiOsWritePciConfiguration(ACPI_PCI_ID *PciId, UINT32 Reg, UINT64 Value, UINT32 Width)
Definition: osl.c:822
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define ACPI_SIGNAL_BREAKPOINT
Definition: acpiosxf.h:74
static PVOID AcpiIrqContext
Definition: osl.c:17
ACPI_STATUS AcpiOsCreateLock(ACPI_SPINLOCK *OutHandle)
Definition: osl.c:463
struct _ACPI_SEM * PACPI_SEM
ACPI_STATUS AcpiOsCreateSemaphore(UINT32 MaxUnits, UINT32 InitialUnits, ACPI_SEMAPHORE *OutHandle)
Definition: osl.c:352
Definition: vfat.h:184
Status
Definition: gdiplustypes.h:24
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
void * AcpiOsAllocate(ACPI_SIZE size)
Definition: osl.c:160
_SEH2_END
Definition: create.c:4424
* PFAST_MUTEX
Definition: extypes.h:17
static ULONG Timeout
Definition: ping.c:61
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
VOID FASTCALL ExAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:23
#define DPFLTR_ERROR_LEVEL
Definition: main.cpp:32
ULONG_PTR KAFFINITY
Definition: compat.h:75
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK _In_ ULONG Vector
Definition: iofuncs.h:798
static PFAST_MUTEX Mutex
Definition: timer.c:22
VOID NTAPI MmUnmapIoSpace(IN PVOID BaseAddress, IN SIZE_T NumberOfBytes)
Definition: iosup.c:193
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
NTSTATUS NTAPI PsCreateSystemThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle, IN PCLIENT_ID ClientId, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext)
Definition: thread.c:602
ACPI_THREAD_ID AcpiOsGetThreadId(void)
Definition: osl.c:217
unsigned short UINT16
unsigned int * PULONG
Definition: retypes.h:1
#define va_start(ap, A)
Definition: acmsvcex.h:91
void AcpiOsFree(void *ptr)
Definition: osl.c:167
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
ACPI_STATUS AcpiOsReadPciConfiguration(ACPI_PCI_ID *PciId, UINT32 Reg, UINT64 *Value, UINT32 Width)
Definition: osl.c:793
#define DPRINT1
Definition: precomp.h:8
ACPI_STATUS AcpiOsCreateMutex(ACPI_MUTEX *OutHandle)
Definition: osl.c:271
ACPI_STATUS AcpiOsWaitSemaphore(ACPI_SEMAPHORE Handle, UINT32 Units, UINT16 Timeout)
Definition: osl.c:393
__GNU_EXTENSION typedef unsigned __int64 * PULONGLONG
Definition: ntbasedef.h:390
ACPI_STATUS AcpiOsTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_TABLE_HEADER **NewTable)
Definition: osl.c:72
static BOOLEAN AcpiInterruptHandlerRegistered
Definition: osl.c:15
void AcpiOsReleaseMutex(ACPI_MUTEX Handle)
Definition: osl.c:333
struct tagContext Context
Definition: acpixf.h:1012
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:565
BOOLEAN AcpiOsWritable(void *Memory, ACPI_SIZE Length)
Definition: osl.c:196
signed int INT32
void WRITE_PORT_UCHAR(PUCHAR Address, UCHAR Value)
Definition: mach.c:539
void ACPI_INTERNAL_VAR_XFACE AcpiOsPrintf(const char *Fmt,...)
Definition: osl.c:851
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress(IN PVOID Address)
Definition: stubs.c:682
#define ACPI_MUTEX
Definition: actypes.h:273
ACPI_STATUS AcpiOsWritePort(ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width)
Definition: osl.c:731
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
void * AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS phys, ACPI_SIZE length)
Definition: osl.c:108
UINT16 Function
Definition: actypes.h:1329
ACPI_STATUS AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 *Value, UINT32 Width)
Definition: osl.c:634
USHORT NTAPI READ_PORT_USHORT(IN PUSHORT Port)
Definition: portio.c:63
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
void AcpiOsRedirectOutput(void *Destination)
Definition: osl.c:876
unsigned long long UINT64
void AcpiOsDeleteMutex(ACPI_MUTEX Handle)
Definition: osl.c:293
void AcpiOsVprintf(const char *Fmt, va_list Args)
Definition: osl.c:865
ULONG NTAPI HalSetBusDataByOffset(IN BUS_DATA_TYPE BusDataType, IN ULONG BusNumber, IN ULONG SlotNumber, IN PVOID Buffer, IN ULONG Offset, IN ULONG Length)
Definition: bus.c:123
ACPI_STATUS AcpiOsReadPort(ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width)
Definition: osl.c:701
unsigned char UINT8
BOOLEAN AcpiOsReadable(void *Memory, ACPI_SIZE Length)
Definition: osl.c:175
KSPIN_LOCK Lock
Definition: osl.c:348
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define AE_OK
Definition: acexcep.h:97
#define ACPI_THREAD_ID
Definition: actypes.h:144
unsigned short * PUSHORT
Definition: retypes.h:2
VOID NTAPI KeStallExecutionProcessor(IN ULONG MicroSeconds)
Definition: ntoskrnl.c:99
void(ACPI_SYSTEM_XFACE * ACPI_OSD_EXEC_CALLBACK)(void *Context)
Definition: actypes.h:1115
_Must_inspect_result_ _In_ PFILE_OBJECT _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ FLT_IO_OPERATION_FLAGS _Out_opt_ PULONG BytesRead
Definition: fltkernel.h:1255
#define AE_ERROR
Definition: acexcep.h:109
#define ACPI_SIGNAL_FATAL
Definition: acpiosxf.h:73
ACPI_STATUS AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES *PredefinedObject, ACPI_STRING *NewValue)
Definition: osl.c:55
LONGLONG QuadPart
Definition: typedefs.h:112
_In_ PKSERVICE_ROUTINE ServiceRoutine
Definition: iofuncs.h:798
void AcpiOsDeleteLock(ACPI_SPINLOCK Handle)
Definition: osl.c:485