arch/all-pc/acpica/generate/aros/acpios_aros.c

   1 /*
   2  * Copyright (C) 2012, The AROS Development Team
   3  * All right reserved.
   4  * Author: Jason S. McMullan <jason.mcmullan@gmail.com>
   5  *
   6  * Licensed under the AROS PUBLIC LICENSE (APL) Version 1.1
   7  */
   8 #define __ACPICA_NOLIBBASE__
   9 #define DEBUG 1
  10 #include <aros/debug.h>
  11
  12 #include "acpica_intern.h"
  13
  14 #include <hardware/efi/config.h>
  15
  16 #include <proto/exec.h>
  17 #include <proto/timer.h>
  18 #include <proto/efi.h>
  19 #include <proto/kernel.h>
  20
  21 #include <proto/acpica.h>
  22
  23 #include <asm/io.h>
  24
  25 #include <devices/timer.h>
  26
  27 #define _COMPONENT          ACPI_OS_SERVICES
  28         ACPI_MODULE_NAME    ("osarosxf")
  29
  30 /* FIXME: __aros_getbase_ACPICABase() for internal use should be handled
  31    properly by genmodule
  32 */
  33 #undef __aros_getbase_ACPICABase
  34 struct Library *__aros_getbase_ACPICABase(void);
  35
  36 ACPI_STATUS AcpiOsInitialize (void)
  37 {
  38     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
  39
  40     D(bug("[ACPI]AcpiOsInitialize(): ACPICABase=0x%x\n", ACPICABase));
  41
  42     if ((ACPICABase->ab_TimeMsgPort = CreateMsgPort())) {
  43         if ((ACPICABase->ab_TimeRequest = CreateIORequest(ACPICABase->ab_TimeMsgPort, sizeof(*ACPICABase->ab_TimeRequest)))) {
  44             ACPICABase->ab_TimerBase = (struct Library *)ACPICABase->ab_TimeRequest->tr_node.io_Device;
  45             return AE_OK;
  46         }
  47         DeleteMsgPort(ACPICABase->ab_TimeMsgPort);
  48     }
  49
  50     return AE_NO_MEMORY;
  51 }
  52
  53 ACPI_STATUS AcpiOsTerminate (void)
  54 {
  55     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
  56
  57     D(bug("[ACPI]AcpiOsTerminate(): ACPICABase=0x%x\n", ACPICABase));
  58
  59     DeleteIORequest(ACPICABase->ab_TimeRequest);
  60     DeleteMsgPort(ACPICABase->ab_TimeMsgPort);
  61
  62     return AE_OK;
  63 }
  64
  65 ACPI_PHYSICAL_ADDRESS AcpiOsGetRootPointer(void)
  66 {
  67     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
  68
  69     D(bug("[ACPI]AcpiOsGetRootPointer(): ACPICABase=0x%x\n", ACPICABase));
  70
  71     if (ACPICABase->ab_RootPointer == 0) {
  72         struct Library *EFIBase = OpenResource("efi.resource");
  73         if (EFIBase) {
  74             const uuid_t acpi_20_guid = ACPI_20_TABLE_GUID;
  75             const uuid_t acpi_10_guid = ACPI_TABLE_GUID;
  76             ACPICABase->ab_RootPointer = (ACPI_PHYSICAL_ADDRESS)EFI_FindConfigTable(&acpi_20_guid);
  77
  78             /* No ACPI 2.0 table? */
  79             if (ACPICABase->ab_RootPointer == 0) {
  80                 ACPICABase->ab_RootPointer = (ACPI_PHYSICAL_ADDRESS)EFI_FindConfigTable(&acpi_10_guid);
  81             }
  82         }
  83     }
  84
  85     /* Nope, no EFI available... Scan the ROM area
  86      */
  87     if (ACPICABase->ab_RootPointer == 0) {
  88         AcpiFindRootPointer(&ACPICABase->ab_RootPointer);
  89     }
  90
  91     return ACPICABase->ab_RootPointer;
  92 }
  93
  94 ACPI_STATUS AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES *PredefinedObject, ACPI_STRING *NewValue)
  95 {
  96     *NewValue = NULL;
  97     return AE_OK;
  98 }
  99
 100 ACPI_STATUS AcpiOsTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_TABLE_HEADER **NewTable)
 101 {
 102     *NewTable = NULL;
 103     return AE_OK;
 104 }
 105
 106 ACPI_STATUS AcpiOsPhysicalTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_PHYSICAL_ADDRESS *NewAddress, UINT32 *NewTableLength)
 107 {
 108     *NewAddress = 0;
 109     return AE_OK;
 110 }
 111
 112 void *AcpiOsMapMemory (ACPI_PHYSICAL_ADDRESS PhysicalAddress, ACPI_SIZE Length)
 113 {
 114     return (void *)PhysicalAddress;
 115 }
 116
 117 void AcpiOsUnmapMemory(void *LogicalAddress, ACPI_SIZE Length)
 118 {
 119     return;
 120 }
 121
 122 ACPI_STATUS AcpiOsGetPhysicalAddress(void *LogicalAddress, ACPI_PHYSICAL_ADDRESS *PhysicalAddress)
 123 {
 124     *PhysicalAddress = (IPTR)LogicalAddress;
 125     return AE_OK;
 126 }
 127
 128 void *AcpiOsAllocate(ACPI_SIZE Size)
 129 {
 130     return AllocVec(Size, MEMF_PUBLIC);
 131 }
 132
 133 void AcpiOsFree(void *Memory)
 134 {
 135     FreeVec(Memory);
 136 }
 137
 138 BOOLEAN AcpiOsReadable(void *Memory, ACPI_SIZE Length)
 139 {
 140     return TRUE;
 141 }
 142
 143 BOOLEAN AcpiOsWritable(void *Memory, ACPI_SIZE Length)
 144 {
 145     /* First 4K page is not writable on any AROS architecture */
 146     return ((IPTR)Memory < 4096) ? FALSE : TRUE;
 147 }
 148
 149 ACPI_THREAD_ID AcpiOsGetThreadId(void)
 150 {
 151     ACPI_THREAD_ID tid;
 152
 153     tid = (ACPI_THREAD_ID)(ACPI_PHYSICAL_ADDRESS)FindTask(NULL);
 154
 155     /* If we are running during kernel bring-up, return
 156      * TID 1
 157      */
 158     if (tid == 0)
 159         tid = 1;
 160
 161     return tid;
 162 }
 163
 164 ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, void *Context)
 165 {
 166     /* TODO: Create a thread */
 167     bug("FIXME: %s\n", __func__);
 168     return AE_NOT_IMPLEMENTED;
 169 }
 170
 171 void AcpiOsSleep(UINT64 Milliseconds)
 172 {
 173     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
 174
 175     D(bug("[ACPI]AcpiOsSleep(): ACPICABase=0x%x\n", ACPICABase));
 176
 177     ACPICABase->ab_TimeRequest->tr_node.io_Command = TR_ADDREQUEST;
 178     ACPICABase->ab_TimeRequest->tr_time.tv_secs = Milliseconds / 1000;
 179     ACPICABase->ab_TimeRequest->tr_time.tv_micro = (Milliseconds % 1000) * 1000;
 180     DoIO((struct IORequest *)ACPICABase->ab_TimeRequest);
 181 }
 182
 183 void AcpiOsStall(UINT32 Microseconds)
 184 {
 185     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
 186
 187     D(bug("[ACPI]AcpiOsStall(): ACPICABase=0x%x\n", ACPICABase));
 188
 189     ACPICABase->ab_TimeRequest->tr_node.io_Command = TR_ADDREQUEST;
 190     ACPICABase->ab_TimeRequest->tr_time.tv_secs = Microseconds / 1000000;
 191     ACPICABase->ab_TimeRequest->tr_time.tv_micro = (Microseconds % 1000000);
 192     DoIO((struct IORequest *)ACPICABase->ab_TimeRequest);
 193 }
 194
 195 void AcpiOsWaitEventsComplete(void)
 196 {
 197     bug("FIXME: %s\n", __func__);
 198 }
 199
 200 ACPI_STATUS AcpiOsCreateSemaphore(UINT32 MaxUnits, UINT32 InitialUnits, ACPI_SEMAPHORE *OutHandle)
 201 {
 202     struct SignalSemaphore *Handle;
 203
 204     Handle = ACPI_ALLOCATE(sizeof(*Handle));
 205     if (Handle) {
 206         InitSemaphore(Handle);
 207         *OutHandle = Handle;
 208         return AE_OK;
 209     }
 210     return AE_NO_MEMORY;
 211 }
 212
 213 ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)
 214 {
 215     ACPI_FREE(Handle);
 216     return AE_OK;
 217 }
 218
 219 ACPI_STATUS AcpiOsWaitSemaphore(ACPI_SEMAPHORE Handle, UINT32 Units, UINT16 Timeout)
 220 {
 221     if (Timeout != 0xffff)
 222         bug("FIXME: %s, Timeout=0x%04x\n", __func__, Timeout);
 223
 224     if (Timeout == 0) {
 225         if (AttemptSemaphore(Handle)) {
 226             return AE_OK;
 227         } else {
 228             return AE_TIME;
 229         }
 230     }
 231
 232     /* Forever.. */
 233     ObtainSemaphore(Handle);
 234
 235     return AE_OK;
 236 }
 237
 238 ACPI_STATUS AcpiOsSignalSemaphore(ACPI_SEMAPHORE Handle, UINT32 Units)
 239 {
 240     ReleaseSemaphore(Handle);
 241     return AE_OK;
 242 }
 243
 244 /* FIXME: Use SpinLock primitives once they exist in kernel.resource! */
 245 #define MIN_PRI -128
 246 struct SpinLock {
 247     volatile ULONG sl_Lock;
 248 };
 249
 250 static inline struct SpinLock *CreateSpin(VOID)
 251 {
 252     return AllocVec(sizeof(struct SpinLock), MEMF_ANY | MEMF_CLEAR);
 253 }
 254
 255 static inline void DeleteSpin(struct SpinLock *sl)
 256 {
 257     Disable();
 258     while (sl->sl_Lock > 0) {
 259         Enable();
 260         sl->sl_Lock--;
 261     }
 262     Enable();
 263
 264     FreeVec(sl);
 265 }
 266
 267 static inline VOID LockSpin(struct SpinLock *sl)
 268 {
 269     BYTE pri, pri_lower;
 270     struct Task *task = FindTask(NULL);
 271
 272     pri = task->tc_Node.ln_Pri;
 273     pri_lower = pri;
 274
 275     do {
 276         Disable();
 277         if (sl->sl_Lock == 0) {
 278             sl->sl_Lock++;
 279             if (pri_lower != pri)
 280                 SetTaskPri(task, pri);
 281             break;
 282         }
 283         Enable();
 284         if (pri_lower > MIN_PRI)
 285             pri_lower--;
 286         SetTaskPri(task, pri_lower);
 287     } while (1);
 288 }
 289
 290 static inline void UnlockSpin(struct SpinLock *sl)
 291 {
 292     sl->sl_Lock--;
 293     Enable();
 294 }
 295
 296 ACPI_STATUS AcpiOsCreateLock(ACPI_SPINLOCK *OutHandle)
 297 {
 298     *OutHandle = CreateSpin();
 299
 300     return (*OutHandle == NULL) ? AE_NO_MEMORY : AE_OK;
 301 }
 302
 303 void AcpiOsDeleteLock(ACPI_SPINLOCK Handle)
 304 {
 305     DeleteSpin(Handle);
 306 }
 307
 308 ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
 309 {
 310     LockSpin(Handle);
 311     return 1;
 312 }
 313
 314 void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
 315 {
 316     if (Flags == 1)
 317         UnlockSpin(Handle);
 318 }
 319
 320 struct AcpiOsInt {
 321     struct Interrupt ai_Interrupt;
 322     ACPI_OSD_HANDLER ai_Handler;
 323     void *ai_Context;
 324 };
 325
 326 static AROS_INTH1(AcpiOsIntServer, struct AcpiOsInt *, ai)
 327 {
 328     AROS_INTFUNC_INIT
 329
 330     UINT32 ret;
 331
 332     ret = ai->ai_Handler(ai->ai_Context);
 333
 334     return (ret == ACPI_INTERRUPT_HANDLED) ? TRUE : FALSE;
 335
 336     AROS_INTFUNC_EXIT
 337 }
 338
 339 ACPI_STATUS AcpiOsInstallInterruptHandler(UINT32 InterruptLevel, ACPI_OSD_HANDLER Handler, void *Context)
 340 {
 341     struct AcpiOsInt *ai;
 342
 343     if ((ai = ACPI_ALLOCATE(sizeof(*ai)))) {
 344         ai->ai_Interrupt.is_Node.ln_Name = "ACPI";
 345         ai->ai_Interrupt.is_Code = (APTR)AcpiOsIntServer;
 346         ai->ai_Interrupt.is_Data = (APTR)ai;
 347         ai->ai_Handler = Handler;
 348         ai->ai_Context = Context;
 349         AddIntServer(INTB_KERNEL + InterruptLevel, &ai->ai_Interrupt);
 350         return AE_OK;
 351     }
 352
 353     return AE_NO_MEMORY;
 354 }
 355
 356 ACPI_STATUS AcpiOsRemoveInterruptHandler(UINT32 InterruptNumber, ACPI_OSD_HANDLER Handler)
 357 {
 358     bug("FIXME: %s (InterruptLevel=%d)\n", __func__, InterruptNumber);
 359     return AE_NOT_IMPLEMENTED;
 360 }
 361
 362 ACPI_STATUS AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 *Value, UINT32 Width)
 363 {
 364     switch (Width) {
 365     case  8: *Value = *(UINT8 *)Address; break;
 366     case 16: *Value = *(UINT16 *)Address; break;
 367     case 32: *Value = *(UINT32 *)Address; break;
 368     case 64: *Value = *(UINT64 *)Address; break;
 369     default: *Value = ~0; break;
 370     }
 371
 372     return AE_OK;
 373 }
 374
 375 ACPI_STATUS AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 Value, UINT32 Width)
 376 {
 377     switch (Width) {
 378     case  8: *(UINT8 *)Address = (UINT8)Value; break;
 379     case 16: *(UINT16 *)Address = (UINT16)Value; break;
 380     case 32: *(UINT32 *)Address = (UINT32)Value; break;
 381     case 64: *(UINT64 *)Address = (UINT64)Value; break;
 382     default: break;
 383     }
 384
 385     return AE_OK;
 386 }
 387
 388 ACPI_STATUS AcpiOsReadPort(ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width)
 389 {
 390     switch (Width) {
 391     case  8: *Value = inb(Address); break;
 392     case 16: *Value = inw(Address); break;
 393     case 32: *Value = inl(Address); break;
 394     default: *Value = ~0; break;
 395     }
 396     return AE_OK;
 397 }
 398
 399 ACPI_STATUS AcpiOsWritePort(ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width)
 400 {
 401     switch (Width) {
 402     case  8: outb(Value,Address); break;
 403     case 16: outw(Value,Address); break;
 404     case 32: outl(Value,Address); break;
 405     default: break;
 406     }
 407     return AE_OK;
 408 }
 409
 410 static UINT8 *find_pci(struct ACPICABase *ACPICABase, ACPI_PCI_ID *PciId)
 411 {
 412     int i;
 413
 414     for (i = 0; i < ACPICABase->ab_PCIs; i++) {
 415         ACPI_MCFG_ALLOCATION *ma = &ACPICABase->ab_PCI[i];
 416         if (PciId->Segment != ma->PciSegment)
 417             continue;
 418         if (PciId->Bus < ma->StartBusNumber ||
 419             PciId->Bus > ma->EndBusNumber)
 420             continue;
 421
 422         return (UINT8 *)(ACPI_PHYSICAL_ADDRESS)ma->Address;
 423     }
 424
 425     return NULL;
 426 }
 427
 428 ACPI_STATUS AcpiOsReadPciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, UINT64 *Value, UINT32 Width)
 429 {
 430     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
 431     UINT8 *ecam;
 432
 433     D(bug("[ACPI]AcpiOsReadPciConfiguration(): ACPICABase=0x%x\n", ACPICABase));
 434
 435     if ((ecam = find_pci(ACPICABase, PciId))) {
 436         UINT32 offset = (PciId->Bus << 20) | (PciId->Device << 15) | (PciId->Function << 12) | Register;
 437         switch (Width) {
 438         case  8: *Value = *(volatile UINT8 *)(ecam + offset); break;
 439         case 16: *Value = *(volatile UINT16 *)(ecam + offset); break;
 440         case 32: *Value = *(volatile UINT32 *)(ecam + offset); break;
 441         case 64: *Value = *(volatile UINT64 *)(ecam + offset); break;
 442         default: *Value = 0; break;
 443         }
 444
 445         return AE_OK;
 446     }
 447
 448     return AE_NOT_FOUND;
 449 }
 450
 451 ACPI_STATUS AcpiOsWritePciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, UINT64 Value, UINT32 Width)
 452 {
 453     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
 454     UINT8 *ecam;
 455
 456     D(bug("[ACPI]AcpiOsWritePciConfiguration(): ACPICABase=0x%x\n", ACPICABase));
 457
 458     if ((ecam = find_pci(ACPICABase, PciId))) {
 459         UINT32 offset = (PciId->Bus << 20) | (PciId->Device << 15) | (PciId->Function << 12) | Register;
 460         switch (Width) {
 461         case  8: *(volatile UINT8 *)(ecam + offset) = Value & 0xff; break;
 462         case 16: *(volatile UINT16 *)(ecam + offset) = Value & 0xffff; break;
 463         case 32: *(volatile UINT32 *)(ecam + offset) = Value & 0xffffffff; break;
 464         case 64: *(volatile UINT64 *)(ecam + offset) = Value; break;
 465         default: break;
 466         }
 467
 468         return AE_OK;
 469     }
 470
 471     return AE_NOT_FOUND;
 472 }
 473
 474 void AcpiOsPrintf(const char *Fmt, ...)
 475 {
 476     va_list Args;
 477
 478     va_start (Args, Fmt);
 479     AcpiOsVprintf (Fmt, Args);
 480     va_end (Args);
 481 }
 482
 483 void AcpiOsVprintf(const char *Format, va_list Args)
 484 {
 485     vkprintf(Format, Args);
 486 }
 487
 488 /* Return current time in 100ns units
 489  */
 490 UINT64 AcpiOsGetTimer(void)
 491 {
 492     struct ACPICABase *ACPICABase = (struct ACPICABase *)__aros_getbase_ACPICABase();
 493     struct Library *TimerBase;
 494     struct timeval tv;
 495
 496     D(bug("[ACPI]AcpiOsGetTimer(): ACPICABase=0x%x\n", ACPICABase));
 497
 498     TimerBase = ACPICABase->ab_TimerBase;
 499
 500     GetSysTime(&tv);
 501
 502     return (tv.tv_secs*1000000ULL + tv.tv_micro)*10;
 503 }
 504
 505 ACPI_STATUS AcpiOsSignal(UINT32 Function, void *Info)
 506 {
 507     bug("FIXME: %s\n", __func__);
 508     return AE_NOT_IMPLEMENTED;
 509 }
 510
 511 ACPI_STATUS AcpiOsGetLine(char *Buffer, UINT32 BufferLength, UINT32 *BytesRead)
 512 {
 513     bug("FIXME: %s\n", __func__);
 514     return AE_NOT_IMPLEMENTED;
 515 }
 516
 517 /*
 518  * AROS Custom Code
 519  */
 520 LONG AcpiScanTables(const char *Signature, const struct Hook *Hook, APTR UserData)
 521 {
 522     int i;
 523     LONG count;
 524
 525     for (count = 0, i = 1; ; i++) {
 526         ACPI_STATUS err;
 527         ACPI_TABLE_HEADER *hdr;
 528         IPTR ok;
 529
 530         err = AcpiGetTable((ACPI_STRING)Signature, i, &hdr);
 531         if (err != AE_OK)
 532             break;
 533
 534         if (Hook) {
 535             ok = CALLHOOKPKT((struct Hook *)Hook, hdr, UserData);
 536         } else {
 537             ok = TRUE;
 538         }
 539         if (ok)
 540             count++;
 541     }
 542
 543     return count;
 544 }
 545
 546 #define ACPI_MAX_INIT_TABLES 64
 547
 548 static int ACPICA_InitTask(struct ACPICABase *ACPICABase)
 549 {
 550     ACPI_STATUS err;
 551     const UINT8 initlevel = ACPI_FULL_INITIALIZATION;
 552
 553     err = AcpiInitializeSubsystem();
 554     if (ACPI_FAILURE(err)) {
 555         D(bug("%s: AcpiInitializeSubsystem() = %d\n", __func__, err));
 556         return FALSE;
 557     }
 558
 559     err = AcpiLoadTables();
 560     if (ACPI_FAILURE(err)) {
 561         D(bug("%s: AcpiLoadTables() = %d\n", __func__, err));
 562         return FALSE;
 563     }
 564
 565     err = AcpiEnableSubsystem(initlevel);
 566     if (ACPI_FAILURE(err)) {
 567         D(bug("%s: AcpiEnableSubsystem(0x%02x) = %d\n", __func__, initlevel, err));
 568         return FALSE;
 569     }
 570
 571     err = AcpiInitializeObjects(initlevel);
 572     if (ACPI_FAILURE(err)) {
 573         D(bug("%s: AcpiInitializeObjects(0x%02x) = %d\n", __func__, initlevel, err));
 574         return FALSE;
 575     }
 576
 577     D(bug("[ACPI] Full initialization complete\n"));
 578
 579     return TRUE;
 580 }
 581
 582 int ACPICA_init(struct ACPICABase *ACPICABase)
 583 {
 584     ACPI_TABLE_MCFG *mcfg;
 585     ACPI_STATUS err;
 586     struct Library *KernelBase;
 587
 588     D(bug("[ACPI]ACPICA_init(ACPICABase=0x%x)\n", ACPICABase));
 589
 590     if ((KernelBase = OpenResource("kernel.resource"))) {
 591         struct TagItem *cmdline = LibFindTagItem(KRN_CmdLine, KrnGetBootInfo());
 592
 593         if (cmdline && strcasestr((char *)cmdline->ti_Data, "noacpi")) {
 594             D(bug("[ACPI] Disabled from command line\n"));
 595             return FALSE;
 596         }
 597     }
 598
 599     AcpiDbgLevel = ~0;
 600
 601     ACPICABase->ab_RootPointer = 0;
 602
 603     err = AcpiInitializeTables(NULL, ACPI_MAX_INIT_TABLES, TRUE);
 604     if (ACPI_FAILURE(err)) {
 605         D(bug("%s: AcpiInitializeTables() = %d\n", __func__, err));
 606         return FALSE;
 607     }
 608
 609     if (AcpiGetTable("MCFG", 1, (ACPI_TABLE_HEADER **)&mcfg) == AE_OK) {
 610         ACPICABase->ab_PCIs = (mcfg->Header.Length - sizeof(*mcfg)) / sizeof(ACPI_MCFG_ALLOCATION);
 611         ACPICABase->ab_PCI = (ACPI_MCFG_ALLOCATION *)&mcfg[1];
 612     } else {
 613         ACPICABase->ab_PCIs = 0;
 614     }
 615
 616     /* Everything else is in the late initialization thread,
 617      * which will start at the highest priority once mulitasking begins
 618      */
 619     if (NewCreateTask(TASKTAG_PC, ACPICA_InitTask, TASKTAG_NAME, "ACPICA_InitTask", TASKTAG_PRI, 127, TASKTAG_ARG1, ACPICABase, TAG_DONE) == NULL) {
 620         AcpiTerminate();
 621         return FALSE;
 622     }
 623
 624     return TRUE;
 625 }
 626 ADD2INITLIB(ACPICA_init,0)
 627
 628 int ACPICA_expunge(struct ACPICABase *ACPICABase)
 629 {
 630     AcpiTerminate();
 631
 632     return TRUE;
 633 }
 634 ADD2EXPUNGELIB(ACPICA_expunge, 0)