Warning, cross-references for /kernel/drivers/acpi/quest-acpica.c need to be fixed.
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116
0117
0118
0119
0120
0121
0122
0123
0124
0125
0126
0127
0128
0129
0130
0131
0132
0133
0134
0135
0136
0137 #include"smp/spinlock.h"
0138 #include"smp/semaphore.h"
0139 #include"kernel.h"
0140 #include"drivers/pci/pci.h"
0141 #include"drivers/acpi/acpi.h"
0142 #include"util/printf.h"
0143 #include"mem/mem.h"
0144 #include"smp/smp.h"
0145 #include"smp/apic.h"
0146 #include "sched/sched.h"
0147
0148
0149
0150
0151 ACPI_STATUS
0152 AcpiOsInitialize (void)
0153 {
0154 return AE_OK;
0155 }
0156
0157
0158 ACPI_STATUS
0159 AcpiOsTerminate (void)
0160 {
0161 return AE_OK;
0162 }
0163
0164
0165
0166
0167
0168
0169 ACPI_PHYSICAL_ADDRESS
0170 AcpiOsGetRootPointer (void)
0171 {
0172 ACPI_SIZE addr;
0173 if (AcpiFindRootPointer (&addr) == AE_OK)
0174 return (ACPI_PHYSICAL_ADDRESS) addr;
0175 else
0176 return 0;
0177 }
0178
0179
0180 ACPI_STATUS
0181 AcpiOsPredefinedOverride (const ACPI_PREDEFINED_NAMES * InitVal,
0182 ACPI_STRING * NewVal)
0183 {
0184 *NewVal = NULL;
0185 return AE_OK;
0186 }
0187
0188
0189 ACPI_STATUS
0190 AcpiOsTableOverride (ACPI_TABLE_HEADER * ExistingTable,
0191 ACPI_TABLE_HEADER ** NewTable)
0192 {
0193 *NewTable = NULL;
0194 return AE_OK;
0195 }
0196
0197
0198
0199
0200
0201
0202 ACPI_STATUS
0203 AcpiOsCreateLock (ACPI_SPINLOCK * OutHandle)
0204 {
0205 *OutHandle = AcpiOsAllocate (sizeof (spinlock));
0206 spinlock_init (*OutHandle);
0207 return AE_OK;
0208 }
0209
0210
0211 void
0212 AcpiOsDeleteLock (ACPI_SPINLOCK Handle)
0213 {
0214 AcpiOsFree (Handle);
0215 return;
0216 }
0217
0218
0219 ACPI_CPU_FLAGS
0220 AcpiOsAcquireLock (ACPI_SPINLOCK Handle)
0221 {
0222 spinlock_lock (Handle);
0223 return 0;
0224 }
0225
0226
0227 void
0228 AcpiOsReleaseLock (ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
0229 {
0230 spinlock_unlock (Handle);
0231 return;
0232 }
0233
0234
0235
0236
0237
0238
0239 ACPI_STATUS
0240 AcpiOsCreateSemaphore (UINT32 MaxUnits,
0241 UINT32 InitialUnits, ACPI_SEMAPHORE * OutHandle)
0242 {
0243 *OutHandle = AcpiOsAllocate (sizeof (semaphore));
0244 semaphore_init (*OutHandle, MaxUnits, InitialUnits);
0245 return AE_OK;
0246 }
0247
0248
0249 ACPI_STATUS
0250 AcpiOsDeleteSemaphore (ACPI_SEMAPHORE Handle)
0251 {
0252 semaphore_destroy (Handle);
0253 AcpiOsFree (Handle);
0254 return AE_OK;
0255 }
0256
0257
0258 ACPI_STATUS
0259 AcpiOsWaitSemaphore (ACPI_SEMAPHORE Handle, UINT32 Units, UINT16 Timeout)
0260 {
0261 semaphore_wait (Handle, Units, Timeout);
0262 return AE_OK;
0263 }
0264
0265
0266 ACPI_STATUS
0267 AcpiOsSignalSemaphore (ACPI_SEMAPHORE Handle, UINT32 Units)
0268 {
0269 if (semaphore_signal (Handle, Units) == 0)
0270 return AE_OK;
0271 else
0272 return AE_LIMIT;
0273 }
0274
0275
0276
0277
0278
0279
0280
0281 #if (ACPI_MUTEX_TYPE != ACPI_BINARY_SEMAPHORE)
0282
0283 ACPI_STATUS
0284 AcpiOsCreateMutex (ACPI_MUTEX * OutHandle)
0285 {
0286 return;
0287 }
0288
0289
0290 void
0291 AcpiOsDeleteMutex (ACPI_MUTEX Handle)
0292 {
0293 return;
0294 }
0295
0296
0297 ACPI_STATUS
0298 AcpiOsAcquireMutex (ACPI_MUTEX Handle, UINT16 Timeout)
0299 {
0300 return AE_NOT_IMPLEMENTED;
0301 }
0302
0303
0304 void
0305 AcpiOsReleaseMutex (ACPI_MUTEX Handle)
0306 {
0307 return;
0308 }
0309
0310 #endif
0311
0312
0313 void *
0314 AcpiOsAllocate (ACPI_SIZE Size)
0315 {
0316
0317 uint8 *ptr;
0318 pow2_alloc (Size, &ptr);
0319 return (void *) ptr;
0320 }
0321
0322 void
0323 AcpiOsFree (void *Memory)
0324 {
0325 pow2_free ((uint8 *) Memory);
0326 }
0327
0328 void *
0329 AcpiOsMapMemory (ACPI_PHYSICAL_ADDRESS Where, ACPI_SIZE Length)
0330 {
0331 ACPI_PHYSICAL_ADDRESS start_frame = Where & (~0xFFF);
0332 ACPI_PHYSICAL_ADDRESS end_frame = (Where + Length) & (~0xFFF);
0333 ACPI_SIZE num_frames = ((end_frame - start_frame) >> 12) + 1;
0334 void *virt = map_contiguous_virtual_pages (start_frame | 3, num_frames);
0335 if (virt)
0336 return (void *) ((uint32) virt | (Where & 0xFFF));
0337 else
0338 return NULL;
0339 }
0340
0341
0342 void
0343 AcpiOsUnmapMemory (void *LogicalAddress, ACPI_SIZE Size)
0344 {
0345 uint32 start_addr = (uint32) LogicalAddress & (~0xFFF);
0346 uint32 end_addr = ((uint32) LogicalAddress + Size) & (~0xFFF);
0347 ACPI_SIZE num_pages = ((end_addr - start_addr) >> 12) + 1;
0348
0349 return unmap_virtual_pages ((void *) start_addr, num_pages);
0350 }
0351
0352
0353 ACPI_STATUS
0354 AcpiOsGetPhysicalAddress (void *LogicalAddress,
0355 ACPI_PHYSICAL_ADDRESS * PhysicalAddress)
0356 {
0357 *PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) get_phys_addr (LogicalAddress);
0358 return AE_OK;
0359 }
0360
0361
0362
0363 #if 0
0364
0365
0366
0367 ACPI_STATUS
0368 AcpiOsCreateCache (char *CacheName,
0369 UINT16 ObjectSize,
0370 UINT16 MaxDepth, ACPI_CACHE_T ** ReturnCache)
0371 {
0372 return AE_NOT_IMPLEMENTED;
0373 }
0374
0375
0376 ACPI_STATUS
0377 AcpiOsDeleteCache (ACPI_CACHE_T * Cache)
0378 {
0379 return AE_NOT_IMPLEMENTED;
0380 }
0381
0382
0383 ACPI_STATUS
0384 AcpiOsPurgeCache (ACPI_CACHE_T * Cache)
0385 {
0386 return AE_NOT_IMPLEMENTED;
0387 }
0388
0389
0390 void *
0391 AcpiOsAcquireObject (ACPI_CACHE_T * Cache)
0392 {
0393 return NULL;
0394 }
0395
0396
0397 ACPI_STATUS
0398 AcpiOsReleaseObject (ACPI_CACHE_T * Cache, void *Object)
0399 {
0400 return AE_NOT_IMPLEMENTED;
0401 }
0402
0403 #endif
0404
0405
0406
0407
0408
0409 ACPI_OSD_HANDLER acpi_service_routine = NULL;
0410 void *acpi_service_routine_context;
0411
0412 ACPI_STATUS
0413 AcpiOsInstallInterruptHandler (UINT32 InterruptNumber,
0414 ACPI_OSD_HANDLER ServiceRoutine, void *Context)
0415 {
0416 logger_printf ("AcpiOsInstallInterruptHandler (0x%X, 0x%p, 0x%p)\n",
0417 InterruptNumber, ServiceRoutine, Context);
0418
0419 acpi_service_routine = ServiceRoutine;
0420 acpi_service_routine_context = Context;
0421
0422
0423 return AE_OK;
0424 }
0425
0426
0427 ACPI_STATUS
0428 AcpiOsRemoveInterruptHandler (UINT32 InterruptNumber,
0429 ACPI_OSD_HANDLER ServiceRoutine)
0430 {
0431 acpi_service_routine = NULL;
0432 return AE_OK;
0433 }
0434
0435
0436
0437
0438
0439
0440 ACPI_THREAD_ID
0441 AcpiOsGetThreadId (void)
0442 {
0443
0444
0445
0446
0447
0448
0449 return str () || 1;
0450 }
0451
0452
0453 ACPI_STATUS
0454 AcpiOsExecute (ACPI_EXECUTE_TYPE Type,
0455 ACPI_OSD_EXEC_CALLBACK Function, void *Context)
0456 {
0457 return AE_NOT_IMPLEMENTED;
0458 }
0459
0460
0461 void
0462 AcpiOsWaitEventsComplete (void *Context)
0463 {
0464 return;
0465 }
0466
0467
0468 void
0469 AcpiOsSleep (ACPI_INTEGER Milliseconds)
0470 {
0471 sched_usleep (Milliseconds * 1000);
0472 }
0473
0474
0475 void
0476 AcpiOsStall (UINT32 Microseconds)
0477 {
0478 tsc_delay_usec (Microseconds);
0479 }
0480
0481
0482
0483
0484
0485
0486 ACPI_STATUS
0487 AcpiOsReadPort (ACPI_IO_ADDRESS Address, UINT32 * Value, UINT32 Width)
0488 {
0489 switch (Width) {
0490 case 8:
0491 *Value = inb (Address);
0492 break;
0493 case 16:
0494 *Value = inw (Address);
0495 break;
0496 case 32:
0497 *Value = inl (Address);
0498 break;
0499 }
0500
0501 return AE_OK;
0502 }
0503
0504
0505 ACPI_STATUS
0506 AcpiOsWritePort (ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width)
0507 {
0508
0509 switch (Width) {
0510 case 8:
0511 outb ((UINT8) Value, Address);
0512 break;
0513 case 16:
0514 outw ((UINT16) Value, Address);
0515 break;
0516 case 32:
0517 outl (Value, Address);
0518 break;
0519 }
0520 return AE_OK;
0521 }
0522
0523
0524
0525
0526
0527
0528 ACPI_STATUS
0529 AcpiOsReadMemory (ACPI_PHYSICAL_ADDRESS Address, UINT32 * Value, UINT32 Width)
0530 {
0531 logger_printf ("AcpiOsReadMemory (0x%p, %d)\n", Address, Width);
0532 if (Width != 8 && Width != 16 && Width != 32)
0533 return AE_BAD_PARAMETER;
0534 u32 frame = Address & ~(0xFFF);
0535 u32 offset = Address - frame;
0536 u8 *virt = map_virtual_page (frame | 3);
0537 if (!virt) return AE_NO_MEMORY;
0538 switch (Width) {
0539 case 8:
0540 *Value = *((u8 *) (&virt[offset]));
0541 break;
0542 case 16:
0543 *Value = *((u16 *) (&virt[offset]));
0544 break;
0545 case 32:
0546 *Value = *((u32 *) (&virt[offset]));
0547 break;
0548 }
0549 unmap_virtual_page (virt);
0550 return AE_OK;
0551 }
0552
0553
0554 ACPI_STATUS
0555 AcpiOsWriteMemory (ACPI_PHYSICAL_ADDRESS Address, UINT32 Value, UINT32 Width)
0556 {
0557 logger_printf ("AcpiOsWriteMemory (0x%p, 0x%p, %d)\n", Address, Value, Width);
0558 if (Width != 8 && Width != 16 && Width != 32)
0559 return AE_BAD_PARAMETER;
0560 u32 frame = Address & ~(0xFFF);
0561 u32 offset = Address - frame;
0562 u8 *virt = map_virtual_page (frame | 3);
0563 if (!virt) return AE_NO_MEMORY;
0564 switch (Width) {
0565 case 8:
0566 *((u8 *) (&virt[offset])) = (u8) Value;
0567 break;
0568 case 16:
0569 *((u16 *) (&virt[offset])) = (u16) Value;
0570 break;
0571 case 32:
0572 *((u32 *) (&virt[offset])) = (u32) Value;
0573 break;
0574 }
0575 unmap_virtual_page (virt);
0576 return AE_OK;
0577 }
0578
0579
0580
0581
0582
0583
0584
0585
0586 ACPI_STATUS
0587 AcpiOsReadPciConfiguration (ACPI_PCI_ID * PciId,
0588 UINT32 Reg, void *Value, UINT32 Width)
0589 {
0590 pci_config_addr a;
0591 uint8 v8;
0592 uint16 v16;
0593 uint32 v32;
0594 com1_printf
0595 ("AcpiOsReadPciConfiguration(%.4X:%.4X:%.4X:%.4X, %.8X, ..., %d)",
0596 PciId->Segment, PciId->Bus, PciId->Device, PciId->Function, Reg, Width);
0597 pci_config_addr_init (&a, PciId->Bus, PciId->Device, PciId->Function, Reg);
0598 switch (Width) {
0599 case 8:
0600 v8 = pci_read_byte (a);
0601 *((ACPI_INTEGER *) Value) = (ACPI_INTEGER) v8;
0602 break;
0603 case 16:
0604 v16 = pci_read_word (a);
0605 *((ACPI_INTEGER *) Value) = (ACPI_INTEGER) v16;
0606 break;
0607 case 32:
0608 v32 = pci_read_dword (a);
0609 *((ACPI_INTEGER *) Value) = (ACPI_INTEGER) v32;
0610 break;
0611 default:
0612 com1_printf (" = error\n");
0613 return AE_BAD_PARAMETER;
0614 }
0615 com1_printf (" = 0x%x\n", *((ACPI_INTEGER *) Value));
0616 return AE_OK;
0617 }
0618
0619
0620 ACPI_STATUS
0621 AcpiOsWritePciConfiguration (ACPI_PCI_ID * PciId,
0622 UINT32 Reg, ACPI_INTEGER Value, UINT32 Width)
0623 {
0624 pci_config_addr a;
0625 com1_printf ("AcpiOsWritePciConfiguration\n");
0626 pci_config_addr_init (&a, PciId->Bus, PciId->Device, PciId->Function, Reg);
0627 switch (Width) {
0628 case 8:
0629 pci_write_byte (a, (uint8) Value);
0630 break;
0631 case 16:
0632 pci_write_word (a, (uint16) Value);
0633 break;
0634 case 32:
0635 pci_write_dword (a, (uint32) Value);
0636 break;
0637 default:
0638 return AE_BAD_PARAMETER;
0639 }
0640 return AE_OK;
0641 }
0642
0643
0644
0645
0646
0647
0648 void
0649 AcpiOsDerivePciId (ACPI_HANDLE Rhandle,
0650 ACPI_HANDLE Chandle, ACPI_PCI_ID ** PciId)
0651 {
0652 com1_printf ("AcpiOsDerivePciId\n");
0653 return;
0654 }
0655
0656
0657
0658
0659
0660
0661 ACPI_STATUS
0662 AcpiOsValidateInterface (char *Interface)
0663 {
0664 logger_printf ("AcpiOsValidateInterface (%s)\n", Interface);
0665 return AE_SUPPORT;
0666 }
0667
0668
0669 BOOLEAN
0670 AcpiOsReadable (void *Pointer, ACPI_SIZE Length)
0671 {
0672 return AE_NOT_IMPLEMENTED;
0673 }
0674
0675
0676 BOOLEAN
0677 AcpiOsWritable (void *Pointer, ACPI_SIZE Length)
0678 {
0679 return AE_NOT_IMPLEMENTED;
0680 }
0681
0682
0683 UINT64
0684 AcpiOsGetTimer (void)
0685 {
0686 return AE_NOT_IMPLEMENTED;
0687 }
0688
0689
0690 ACPI_STATUS
0691 AcpiOsSignal (UINT32 Function, void *Info)
0692 {
0693 return AE_NOT_IMPLEMENTED;
0694 }
0695
0696
0697
0698
0699
0700
0701 void ACPI_INTERNAL_VAR_XFACE
0702 AcpiOsPrintf (const char *Fmt, ...)
0703 {
0704 va_list Args;
0705 va_start (Args, Fmt);
0706 AcpiOsVprintf (Fmt, Args);
0707 va_end (Args);
0708 }
0709
0710
0711 void
0712 AcpiOsVprintf (const char *Format, va_list Args)
0713 {
0714 fun_vprintf (com1_putc, Format, Args);
0715 }
0716
0717
0718 void
0719 AcpiOsRedirectOutput (void *Destination)
0720 {
0721 return;
0722 }
0723
0724
0725
0726
0727
0728
0729 UINT32
0730 AcpiOsGetLine (char *Buffer)
0731 {
0732 return 0;
0733 }
0734
0735
0736
0737
0738
0739
0740 void *
0741 AcpiOsOpenDirectory (char *Pathname,
0742 char *WildcardSpec, char RequestedFileType)
0743 {
0744 return NULL;
0745 }
0746
0747 char *
0748 AcpiOsGetNextFilename (void *DirHandle)
0749 {
0750 return NULL;
0751 }
0752
0753
0754 void
0755 AcpiOsCloseDirectory (void *DirHandle)
0756 {
0757 return;
0758 }
0759
0760
0761
0762
0763
0764
0765
0766
0767
0768
0769