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