osunixxf.c revision 250838
189051Sjake/****************************************************************************** 289051Sjake * 389051Sjake * Module Name: osunixxf - UNIX OSL interfaces 489051Sjake * 589051Sjake *****************************************************************************/ 689051Sjake 789051Sjake/* 889051Sjake * Copyright (C) 2000 - 2013, Intel Corp. 989051Sjake * All rights reserved. 1089051Sjake * 1189051Sjake * Redistribution and use in source and binary forms, with or without 1289051Sjake * modification, are permitted provided that the following conditions 1389051Sjake * are met: 1489051Sjake * 1. Redistributions of source code must retain the above copyright 1589051Sjake * notice, this list of conditions, and the following disclaimer, 1689051Sjake * without modification. 1789051Sjake * 2. Redistributions in binary form must reproduce at minimum a disclaimer 1889051Sjake * substantially similar to the "NO WARRANTY" disclaimer below 1989051Sjake * ("Disclaimer") and any redistribution must be conditioned upon 2089051Sjake * including a substantially similar Disclaimer requirement for further 2189051Sjake * binary redistribution. 2289051Sjake * 3. Neither the names of the above-listed copyright holders nor the names 2389051Sjake * of any contributors may be used to endorse or promote products derived 2489051Sjake * from this software without specific prior written permission. 2589051Sjake * 2689051Sjake * Alternatively, this software may be distributed under the terms of the 27114188Sjake * GNU General Public License ("GPL") version 2 as published by the Free 28114188Sjake * Software Foundation. 29114188Sjake * 3089051Sjake * NO WARRANTY 3189051Sjake * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 3289051Sjake * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 3389051Sjake * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 3491617Sjake * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 3589051Sjake * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 3689051Sjake * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 3789051Sjake * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 3889051Sjake * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 3989051Sjake * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 4089051Sjake * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 4191617Sjake * POSSIBILITY OF SUCH DAMAGES. 42100899Sjake */ 4391617Sjake 4491617Sjake 4591617Sjake/* 4691617Sjake * These interfaces are required in order to compile the ASL compiler and the 4791617Sjake * various ACPICA tools under Linux or other Unix-like system. 4891617Sjake */ 4991617Sjake#include <contrib/dev/acpica/include/acpi.h> 5091617Sjake#include <contrib/dev/acpica/include/accommon.h> 5191617Sjake#include <contrib/dev/acpica/include/amlcode.h> 52102040Sjake#include <contrib/dev/acpica/include/acparser.h> 53102040Sjake#include <contrib/dev/acpica/include/acdebug.h> 5491617Sjake 5591617Sjake#include <stdio.h> 5691617Sjake#include <stdlib.h> 5791617Sjake#include <stdarg.h> 5891617Sjake#include <unistd.h> 5991617Sjake#include <sys/time.h> 6091617Sjake#include <semaphore.h> 6191617Sjake#include <pthread.h> 6291617Sjake#include <errno.h> 6391617Sjake 6491617Sjake#define _COMPONENT ACPI_OS_SERVICES 6591617Sjake ACPI_MODULE_NAME ("osunixxf") 6691617Sjake 6791617Sjake 6891617Sjakeextern FILE *AcpiGbl_DebugFile; 69100899SjakeFILE *AcpiGbl_OutputFile; 7091617Sjake 7191617Sjake 7291617Sjake/* Upcalls to AcpiExec */ 7391617Sjake 7491617SjakeACPI_PHYSICAL_ADDRESS 7591617SjakeAeLocalGetRootPointer ( 7691617Sjake void); 7791617Sjake 7891617Sjakevoid 7991617SjakeAeTableOverride ( 8091617Sjake ACPI_TABLE_HEADER *ExistingTable, 8191617Sjake ACPI_TABLE_HEADER **NewTable); 8291617Sjake 8389051Sjaketypedef void* (*PTHREAD_CALLBACK) (void *); 8491617Sjake 8589051Sjake/* Buffer used by AcpiOsVprintf */ 8691617Sjake 8791617Sjake#define ACPI_VPRINTF_BUFFER_SIZE 512 8891617Sjake 8991617Sjake 9091617Sjake/****************************************************************************** 9189051Sjake * 9291617Sjake * FUNCTION: AcpiOsInitialize, AcpiOsTerminate 9391617Sjake * 9491617Sjake * PARAMETERS: None 9589051Sjake * 9691617Sjake * RETURN: Status 9789051Sjake * 9891617Sjake * DESCRIPTION: Init and terminate. Nothing to do. 9991617Sjake * 10091617Sjake *****************************************************************************/ 10191617Sjake 10291617SjakeACPI_STATUS 10391617SjakeAcpiOsInitialize ( 10491617Sjake void) 10589051Sjake{ 10691617Sjake 10789051Sjake AcpiGbl_OutputFile = stdout; 10891617Sjake return (AE_OK); 10989051Sjake} 11089051Sjake 11189051Sjake 11291617SjakeACPI_STATUS 11391617SjakeAcpiOsTerminate ( 11489051Sjake void) 11589051Sjake{ 11691617Sjake 11789051Sjake return (AE_OK); 11891617Sjake} 11991617Sjake 12091617Sjake 12191617Sjake/****************************************************************************** 12291617Sjake * 12391617Sjake * FUNCTION: AcpiOsGetRootPointer 12491617Sjake * 12591783Sjake * PARAMETERS: None 12691617Sjake * 12791783Sjake * RETURN: RSDP physical address 12889051Sjake * 12989051Sjake * DESCRIPTION: Gets the ACPI root pointer (RSDP) 13089051Sjake * 13189051Sjake *****************************************************************************/ 13289051Sjake 13391617SjakeACPI_PHYSICAL_ADDRESS 13489051SjakeAcpiOsGetRootPointer ( 13589051Sjake void) 13689051Sjake{ 13791783Sjake 13891783Sjake return (AeLocalGetRootPointer ()); 13991783Sjake} 14089051Sjake 14191783Sjake 14289051Sjake/****************************************************************************** 14391783Sjake * 14491783Sjake * FUNCTION: AcpiOsPredefinedOverride 14589051Sjake * 14691783Sjake * PARAMETERS: InitVal - Initial value of the predefined object 14791783Sjake * NewVal - The new value for the object 14891783Sjake * 14989051Sjake * RETURN: Status, pointer to value. Null pointer returned if not 150102040Sjake * overriding. 151102040Sjake * 15291783Sjake * DESCRIPTION: Allow the OS to override predefined names 15391783Sjake * 15489051Sjake *****************************************************************************/ 15589051Sjake 15691783SjakeACPI_STATUS 15791783SjakeAcpiOsPredefinedOverride ( 15891783Sjake const ACPI_PREDEFINED_NAMES *InitVal, 15991783Sjake ACPI_STRING *NewVal) 16091783Sjake{ 16189051Sjake 16289051Sjake if (!InitVal || !NewVal) 16389051Sjake { 16489051Sjake return (AE_BAD_PARAMETER); 16591783Sjake } 16691617Sjake 16791617Sjake *NewVal = NULL; 16891617Sjake return (AE_OK); 16989051Sjake} 17089051Sjake 17189051Sjake 17289051Sjake/****************************************************************************** 17389051Sjake * 17489051Sjake * FUNCTION: AcpiOsTableOverride 17589051Sjake * 17689051Sjake * PARAMETERS: ExistingTable - Header of current table (probably 17789051Sjake * firmware) 17889051Sjake * NewTable - Where an entire new table is returned. 17991783Sjake * 18089051Sjake * RETURN: Status, pointer to new table. Null pointer returned if no 18191783Sjake * table is available to override 18289051Sjake * 18391783Sjake * DESCRIPTION: Return a different version of a table if one is available 18489051Sjake * 18589051Sjake *****************************************************************************/ 18689051Sjake 18789051SjakeACPI_STATUS 18889051SjakeAcpiOsTableOverride ( 18989051Sjake ACPI_TABLE_HEADER *ExistingTable, 19089051Sjake ACPI_TABLE_HEADER **NewTable) 19189051Sjake{ 19291617Sjake 19389051Sjake if (!ExistingTable || !NewTable) 19489051Sjake { 19591617Sjake return (AE_BAD_PARAMETER); 196 } 197 198 *NewTable = NULL; 199 200#ifdef ACPI_EXEC_APP 201 202 AeTableOverride (ExistingTable, NewTable); 203 return (AE_OK); 204#else 205 206 return (AE_NO_ACPI_TABLES); 207#endif 208} 209 210 211/****************************************************************************** 212 * 213 * FUNCTION: AcpiOsPhysicalTableOverride 214 * 215 * PARAMETERS: ExistingTable - Header of current table (probably firmware) 216 * NewAddress - Where new table address is returned 217 * (Physical address) 218 * NewTableLength - Where new table length is returned 219 * 220 * RETURN: Status, address/length of new table. Null pointer returned 221 * if no table is available to override. 222 * 223 * DESCRIPTION: Returns AE_SUPPORT, function not used in user space. 224 * 225 *****************************************************************************/ 226 227ACPI_STATUS 228AcpiOsPhysicalTableOverride ( 229 ACPI_TABLE_HEADER *ExistingTable, 230 ACPI_PHYSICAL_ADDRESS *NewAddress, 231 UINT32 *NewTableLength) 232{ 233 234 return (AE_SUPPORT); 235} 236 237 238/****************************************************************************** 239 * 240 * FUNCTION: AcpiOsRedirectOutput 241 * 242 * PARAMETERS: Destination - An open file handle/pointer 243 * 244 * RETURN: None 245 * 246 * DESCRIPTION: Causes redirect of AcpiOsPrintf and AcpiOsVprintf 247 * 248 *****************************************************************************/ 249 250void 251AcpiOsRedirectOutput ( 252 void *Destination) 253{ 254 255 AcpiGbl_OutputFile = Destination; 256} 257 258 259/****************************************************************************** 260 * 261 * FUNCTION: AcpiOsPrintf 262 * 263 * PARAMETERS: fmt, ... - Standard printf format 264 * 265 * RETURN: None 266 * 267 * DESCRIPTION: Formatted output. Note: very similar to AcpiOsVprintf 268 * (performance), changes should be tracked in both functions. 269 * 270 *****************************************************************************/ 271 272void ACPI_INTERNAL_VAR_XFACE 273AcpiOsPrintf ( 274 const char *Fmt, 275 ...) 276{ 277 va_list Args; 278 UINT8 Flags; 279 280 281 Flags = AcpiGbl_DbOutputFlags; 282 if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT) 283 { 284 /* Output is directable to either a file (if open) or the console */ 285 286 if (AcpiGbl_DebugFile) 287 { 288 /* Output file is open, send the output there */ 289 290 va_start (Args, Fmt); 291 vfprintf (AcpiGbl_DebugFile, Fmt, Args); 292 va_end (Args); 293 } 294 else 295 { 296 /* No redirection, send output to console (once only!) */ 297 298 Flags |= ACPI_DB_CONSOLE_OUTPUT; 299 } 300 } 301 302 if (Flags & ACPI_DB_CONSOLE_OUTPUT) 303 { 304 va_start (Args, Fmt); 305 vfprintf (AcpiGbl_OutputFile, Fmt, Args); 306 va_end (Args); 307 } 308} 309 310 311/****************************************************************************** 312 * 313 * FUNCTION: AcpiOsVprintf 314 * 315 * PARAMETERS: fmt - Standard printf format 316 * args - Argument list 317 * 318 * RETURN: None 319 * 320 * DESCRIPTION: Formatted output with argument list pointer. Note: very 321 * similar to AcpiOsPrintf, changes should be tracked in both 322 * functions. 323 * 324 *****************************************************************************/ 325 326void 327AcpiOsVprintf ( 328 const char *Fmt, 329 va_list Args) 330{ 331 UINT8 Flags; 332 char Buffer[ACPI_VPRINTF_BUFFER_SIZE]; 333 334 335 /* 336 * We build the output string in a local buffer because we may be 337 * outputting the buffer twice. Using vfprintf is problematic because 338 * some implementations modify the args pointer/structure during 339 * execution. Thus, we use the local buffer for portability. 340 * 341 * Note: Since this module is intended for use by the various ACPICA 342 * utilities/applications, we can safely declare the buffer on the stack. 343 * Also, This function is used for relatively small error messages only. 344 */ 345 vsnprintf (Buffer, ACPI_VPRINTF_BUFFER_SIZE, Fmt, Args); 346 347 Flags = AcpiGbl_DbOutputFlags; 348 if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT) 349 { 350 /* Output is directable to either a file (if open) or the console */ 351 352 if (AcpiGbl_DebugFile) 353 { 354 /* Output file is open, send the output there */ 355 356 fputs (Buffer, AcpiGbl_DebugFile); 357 } 358 else 359 { 360 /* No redirection, send output to console (once only!) */ 361 362 Flags |= ACPI_DB_CONSOLE_OUTPUT; 363 } 364 } 365 366 if (Flags & ACPI_DB_CONSOLE_OUTPUT) 367 { 368 fputs (Buffer, AcpiGbl_OutputFile); 369 } 370} 371 372 373/****************************************************************************** 374 * 375 * FUNCTION: AcpiOsGetLine 376 * 377 * PARAMETERS: Buffer - Where to return the command line 378 * BufferLength - Maximum length of Buffer 379 * BytesRead - Where the actual byte count is returned 380 * 381 * RETURN: Status and actual bytes read 382 * 383 * DESCRIPTION: Formatted input with argument list pointer 384 * 385 *****************************************************************************/ 386 387ACPI_STATUS 388AcpiOsGetLine ( 389 char *Buffer, 390 UINT32 BufferLength, 391 UINT32 *BytesRead) 392{ 393 int Temp; 394 UINT32 i; 395 396 397 for (i = 0; ; i++) 398 { 399 if (i >= BufferLength) 400 { 401 return (AE_BUFFER_OVERFLOW); 402 } 403 404 if ((Temp = getchar ()) == EOF) 405 { 406 return (AE_ERROR); 407 } 408 409 if (!Temp || Temp == '\n') 410 { 411 break; 412 } 413 414 Buffer [i] = (char) Temp; 415 } 416 417 /* Null terminate the buffer */ 418 419 Buffer [i] = 0; 420 421 /* Return the number of bytes in the string */ 422 423 if (BytesRead) 424 { 425 *BytesRead = i; 426 } 427 return (AE_OK); 428} 429 430 431/****************************************************************************** 432 * 433 * FUNCTION: AcpiOsMapMemory 434 * 435 * PARAMETERS: where - Physical address of memory to be mapped 436 * length - How much memory to map 437 * 438 * RETURN: Pointer to mapped memory. Null on error. 439 * 440 * DESCRIPTION: Map physical memory into caller's address space 441 * 442 *****************************************************************************/ 443 444void * 445AcpiOsMapMemory ( 446 ACPI_PHYSICAL_ADDRESS where, 447 ACPI_SIZE length) 448{ 449 450 return (ACPI_TO_POINTER ((ACPI_SIZE) where)); 451} 452 453 454/****************************************************************************** 455 * 456 * FUNCTION: AcpiOsUnmapMemory 457 * 458 * PARAMETERS: where - Logical address of memory to be unmapped 459 * length - How much memory to unmap 460 * 461 * RETURN: None. 462 * 463 * DESCRIPTION: Delete a previously created mapping. Where and Length must 464 * correspond to a previous mapping exactly. 465 * 466 *****************************************************************************/ 467 468void 469AcpiOsUnmapMemory ( 470 void *where, 471 ACPI_SIZE length) 472{ 473 474 return; 475} 476 477 478/****************************************************************************** 479 * 480 * FUNCTION: AcpiOsAllocate 481 * 482 * PARAMETERS: Size - Amount to allocate, in bytes 483 * 484 * RETURN: Pointer to the new allocation. Null on error. 485 * 486 * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS. 487 * 488 *****************************************************************************/ 489 490void * 491AcpiOsAllocate ( 492 ACPI_SIZE size) 493{ 494 void *Mem; 495 496 497 Mem = (void *) malloc ((size_t) size); 498 return (Mem); 499} 500 501 502/****************************************************************************** 503 * 504 * FUNCTION: AcpiOsFree 505 * 506 * PARAMETERS: mem - Pointer to previously allocated memory 507 * 508 * RETURN: None. 509 * 510 * DESCRIPTION: Free memory allocated via AcpiOsAllocate 511 * 512 *****************************************************************************/ 513 514void 515AcpiOsFree ( 516 void *mem) 517{ 518 519 free (mem); 520} 521 522 523#ifdef ACPI_SINGLE_THREADED 524/****************************************************************************** 525 * 526 * FUNCTION: Semaphore stub functions 527 * 528 * DESCRIPTION: Stub functions used for single-thread applications that do 529 * not require semaphore synchronization. Full implementations 530 * of these functions appear after the stubs. 531 * 532 *****************************************************************************/ 533 534ACPI_STATUS 535AcpiOsCreateSemaphore ( 536 UINT32 MaxUnits, 537 UINT32 InitialUnits, 538 ACPI_HANDLE *OutHandle) 539{ 540 *OutHandle = (ACPI_HANDLE) 1; 541 return (AE_OK); 542} 543 544ACPI_STATUS 545AcpiOsDeleteSemaphore ( 546 ACPI_HANDLE Handle) 547{ 548 return (AE_OK); 549} 550 551ACPI_STATUS 552AcpiOsWaitSemaphore ( 553 ACPI_HANDLE Handle, 554 UINT32 Units, 555 UINT16 Timeout) 556{ 557 return (AE_OK); 558} 559 560ACPI_STATUS 561AcpiOsSignalSemaphore ( 562 ACPI_HANDLE Handle, 563 UINT32 Units) 564{ 565 return (AE_OK); 566} 567 568#else 569/****************************************************************************** 570 * 571 * FUNCTION: AcpiOsCreateSemaphore 572 * 573 * PARAMETERS: InitialUnits - Units to be assigned to the new semaphore 574 * OutHandle - Where a handle will be returned 575 * 576 * RETURN: Status 577 * 578 * DESCRIPTION: Create an OS semaphore 579 * 580 *****************************************************************************/ 581 582ACPI_STATUS 583AcpiOsCreateSemaphore ( 584 UINT32 MaxUnits, 585 UINT32 InitialUnits, 586 ACPI_HANDLE *OutHandle) 587{ 588 sem_t *Sem; 589 590 591 if (!OutHandle) 592 { 593 return (AE_BAD_PARAMETER); 594 } 595 596#ifdef __APPLE__ 597 { 598 char *SemaphoreName = tmpnam (NULL); 599 600 Sem = sem_open (SemaphoreName, O_EXCL|O_CREAT, 0755, InitialUnits); 601 if (!Sem) 602 { 603 return (AE_NO_MEMORY); 604 } 605 sem_unlink (SemaphoreName); /* This just deletes the name */ 606 } 607 608#else 609 Sem = AcpiOsAllocate (sizeof (sem_t)); 610 if (!Sem) 611 { 612 return (AE_NO_MEMORY); 613 } 614 615 if (sem_init (Sem, 0, InitialUnits) == -1) 616 { 617 AcpiOsFree (Sem); 618 return (AE_BAD_PARAMETER); 619 } 620#endif 621 622 *OutHandle = (ACPI_HANDLE) Sem; 623 return (AE_OK); 624} 625 626 627/****************************************************************************** 628 * 629 * FUNCTION: AcpiOsDeleteSemaphore 630 * 631 * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore 632 * 633 * RETURN: Status 634 * 635 * DESCRIPTION: Delete an OS semaphore 636 * 637 *****************************************************************************/ 638 639ACPI_STATUS 640AcpiOsDeleteSemaphore ( 641 ACPI_HANDLE Handle) 642{ 643 sem_t *Sem = (sem_t *) Handle; 644 645 646 if (!Sem) 647 { 648 return (AE_BAD_PARAMETER); 649 } 650 651 if (sem_destroy (Sem) == -1) 652 { 653 return (AE_BAD_PARAMETER); 654 } 655 656 return (AE_OK); 657} 658 659 660/****************************************************************************** 661 * 662 * FUNCTION: AcpiOsWaitSemaphore 663 * 664 * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore 665 * Units - How many units to wait for 666 * MsecTimeout - How long to wait (milliseconds) 667 * 668 * RETURN: Status 669 * 670 * DESCRIPTION: Wait for units 671 * 672 *****************************************************************************/ 673 674ACPI_STATUS 675AcpiOsWaitSemaphore ( 676 ACPI_HANDLE Handle, 677 UINT32 Units, 678 UINT16 MsecTimeout) 679{ 680 ACPI_STATUS Status = AE_OK; 681 sem_t *Sem = (sem_t *) Handle; 682#ifndef ACPI_USE_ALTERNATE_TIMEOUT 683 struct timespec Time; 684 int RetVal; 685#endif 686 687 688 if (!Sem) 689 { 690 return (AE_BAD_PARAMETER); 691 } 692 693 switch (MsecTimeout) 694 { 695 /* 696 * No Wait: 697 * -------- 698 * A zero timeout value indicates that we shouldn't wait - just 699 * acquire the semaphore if available otherwise return AE_TIME 700 * (a.k.a. 'would block'). 701 */ 702 case 0: 703 704 if (sem_trywait(Sem) == -1) 705 { 706 Status = (AE_TIME); 707 } 708 break; 709 710 /* Wait Indefinitely */ 711 712 case ACPI_WAIT_FOREVER: 713 714 if (sem_wait (Sem)) 715 { 716 Status = (AE_TIME); 717 } 718 break; 719 720 /* Wait with MsecTimeout */ 721 722 default: 723 724#ifdef ACPI_USE_ALTERNATE_TIMEOUT 725 /* 726 * Alternate timeout mechanism for environments where 727 * sem_timedwait is not available or does not work properly. 728 */ 729 while (MsecTimeout) 730 { 731 if (sem_trywait (Sem) == 0) 732 { 733 /* Got the semaphore */ 734 return (AE_OK); 735 } 736 737 if (MsecTimeout >= 10) 738 { 739 MsecTimeout -= 10; 740 usleep (10 * ACPI_USEC_PER_MSEC); /* ten milliseconds */ 741 } 742 else 743 { 744 MsecTimeout--; 745 usleep (ACPI_USEC_PER_MSEC); /* one millisecond */ 746 } 747 } 748 Status = (AE_TIME); 749#else 750 /* 751 * The interface to sem_timedwait is an absolute time, so we need to 752 * get the current time, then add in the millisecond Timeout value. 753 */ 754 if (clock_gettime (CLOCK_REALTIME, &Time) == -1) 755 { 756 perror ("clock_gettime"); 757 return (AE_TIME); 758 } 759 760 Time.tv_sec += (MsecTimeout / ACPI_MSEC_PER_SEC); 761 Time.tv_nsec += ((MsecTimeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC); 762 763 /* Handle nanosecond overflow (field must be less than one second) */ 764 765 if (Time.tv_nsec >= ACPI_NSEC_PER_SEC) 766 { 767 Time.tv_sec += (Time.tv_nsec / ACPI_NSEC_PER_SEC); 768 Time.tv_nsec = (Time.tv_nsec % ACPI_NSEC_PER_SEC); 769 } 770 771 while (((RetVal = sem_timedwait (Sem, &Time)) == -1) && (errno == EINTR)) 772 { 773 continue; 774 } 775 776 if (RetVal != 0) 777 { 778 if (errno != ETIMEDOUT) 779 { 780 perror ("sem_timedwait"); 781 } 782 Status = (AE_TIME); 783 } 784#endif 785 break; 786 } 787 788 return (Status); 789} 790 791 792/****************************************************************************** 793 * 794 * FUNCTION: AcpiOsSignalSemaphore 795 * 796 * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore 797 * Units - Number of units to send 798 * 799 * RETURN: Status 800 * 801 * DESCRIPTION: Send units 802 * 803 *****************************************************************************/ 804 805ACPI_STATUS 806AcpiOsSignalSemaphore ( 807 ACPI_HANDLE Handle, 808 UINT32 Units) 809{ 810 sem_t *Sem = (sem_t *)Handle; 811 812 813 if (!Sem) 814 { 815 return (AE_BAD_PARAMETER); 816 } 817 818 if (sem_post (Sem) == -1) 819 { 820 return (AE_LIMIT); 821 } 822 823 return (AE_OK); 824} 825 826#endif /* ACPI_SINGLE_THREADED */ 827 828 829/****************************************************************************** 830 * 831 * FUNCTION: Spinlock interfaces 832 * 833 * DESCRIPTION: Map these interfaces to semaphore interfaces 834 * 835 *****************************************************************************/ 836 837ACPI_STATUS 838AcpiOsCreateLock ( 839 ACPI_SPINLOCK *OutHandle) 840{ 841 842 return (AcpiOsCreateSemaphore (1, 1, OutHandle)); 843} 844 845 846void 847AcpiOsDeleteLock ( 848 ACPI_SPINLOCK Handle) 849{ 850 AcpiOsDeleteSemaphore (Handle); 851} 852 853 854ACPI_CPU_FLAGS 855AcpiOsAcquireLock ( 856 ACPI_HANDLE Handle) 857{ 858 AcpiOsWaitSemaphore (Handle, 1, 0xFFFF); 859 return (0); 860} 861 862 863void 864AcpiOsReleaseLock ( 865 ACPI_SPINLOCK Handle, 866 ACPI_CPU_FLAGS Flags) 867{ 868 AcpiOsSignalSemaphore (Handle, 1); 869} 870 871 872/****************************************************************************** 873 * 874 * FUNCTION: AcpiOsInstallInterruptHandler 875 * 876 * PARAMETERS: InterruptNumber - Level handler should respond to. 877 * Isr - Address of the ACPI interrupt handler 878 * ExceptPtr - Where status is returned 879 * 880 * RETURN: Handle to the newly installed handler. 881 * 882 * DESCRIPTION: Install an interrupt handler. Used to install the ACPI 883 * OS-independent handler. 884 * 885 *****************************************************************************/ 886 887UINT32 888AcpiOsInstallInterruptHandler ( 889 UINT32 InterruptNumber, 890 ACPI_OSD_HANDLER ServiceRoutine, 891 void *Context) 892{ 893 894 return (AE_OK); 895} 896 897 898/****************************************************************************** 899 * 900 * FUNCTION: AcpiOsRemoveInterruptHandler 901 * 902 * PARAMETERS: Handle - Returned when handler was installed 903 * 904 * RETURN: Status 905 * 906 * DESCRIPTION: Uninstalls an interrupt handler. 907 * 908 *****************************************************************************/ 909 910ACPI_STATUS 911AcpiOsRemoveInterruptHandler ( 912 UINT32 InterruptNumber, 913 ACPI_OSD_HANDLER ServiceRoutine) 914{ 915 916 return (AE_OK); 917} 918 919 920/****************************************************************************** 921 * 922 * FUNCTION: AcpiOsStall 923 * 924 * PARAMETERS: microseconds - Time to sleep 925 * 926 * RETURN: Blocks until sleep is completed. 927 * 928 * DESCRIPTION: Sleep at microsecond granularity 929 * 930 *****************************************************************************/ 931 932void 933AcpiOsStall ( 934 UINT32 microseconds) 935{ 936 937 if (microseconds) 938 { 939 usleep (microseconds); 940 } 941} 942 943 944/****************************************************************************** 945 * 946 * FUNCTION: AcpiOsSleep 947 * 948 * PARAMETERS: milliseconds - Time to sleep 949 * 950 * RETURN: Blocks until sleep is completed. 951 * 952 * DESCRIPTION: Sleep at millisecond granularity 953 * 954 *****************************************************************************/ 955 956void 957AcpiOsSleep ( 958 UINT64 milliseconds) 959{ 960 961 /* Sleep for whole seconds */ 962 963 sleep (milliseconds / ACPI_MSEC_PER_SEC); 964 965 /* 966 * Sleep for remaining microseconds. 967 * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second). 968 */ 969 usleep ((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC); 970} 971 972 973/****************************************************************************** 974 * 975 * FUNCTION: AcpiOsGetTimer 976 * 977 * PARAMETERS: None 978 * 979 * RETURN: Current time in 100 nanosecond units 980 * 981 * DESCRIPTION: Get the current system time 982 * 983 *****************************************************************************/ 984 985UINT64 986AcpiOsGetTimer ( 987 void) 988{ 989 struct timeval time; 990 991 992 /* This timer has sufficient resolution for user-space application code */ 993 994 gettimeofday (&time, NULL); 995 996 /* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */ 997 998 return (((UINT64) time.tv_sec * ACPI_100NSEC_PER_SEC) + 999 ((UINT64) time.tv_usec * ACPI_100NSEC_PER_USEC)); 1000} 1001 1002 1003/****************************************************************************** 1004 * 1005 * FUNCTION: AcpiOsReadPciConfiguration 1006 * 1007 * PARAMETERS: PciId - Seg/Bus/Dev 1008 * Register - Device Register 1009 * Value - Buffer where value is placed 1010 * Width - Number of bits 1011 * 1012 * RETURN: Status 1013 * 1014 * DESCRIPTION: Read data from PCI configuration space 1015 * 1016 *****************************************************************************/ 1017 1018ACPI_STATUS 1019AcpiOsReadPciConfiguration ( 1020 ACPI_PCI_ID *PciId, 1021 UINT32 Register, 1022 UINT64 *Value, 1023 UINT32 Width) 1024{ 1025 1026 return (AE_OK); 1027} 1028 1029 1030/****************************************************************************** 1031 * 1032 * FUNCTION: AcpiOsWritePciConfiguration 1033 * 1034 * PARAMETERS: PciId - Seg/Bus/Dev 1035 * Register - Device Register 1036 * Value - Value to be written 1037 * Width - Number of bits 1038 * 1039 * RETURN: Status. 1040 * 1041 * DESCRIPTION: Write data to PCI configuration space 1042 * 1043 *****************************************************************************/ 1044 1045ACPI_STATUS 1046AcpiOsWritePciConfiguration ( 1047 ACPI_PCI_ID *PciId, 1048 UINT32 Register, 1049 UINT64 Value, 1050 UINT32 Width) 1051{ 1052 1053 return (AE_OK); 1054} 1055 1056 1057/****************************************************************************** 1058 * 1059 * FUNCTION: AcpiOsReadPort 1060 * 1061 * PARAMETERS: Address - Address of I/O port/register to read 1062 * Value - Where value is placed 1063 * Width - Number of bits 1064 * 1065 * RETURN: Value read from port 1066 * 1067 * DESCRIPTION: Read data from an I/O port or register 1068 * 1069 *****************************************************************************/ 1070 1071ACPI_STATUS 1072AcpiOsReadPort ( 1073 ACPI_IO_ADDRESS Address, 1074 UINT32 *Value, 1075 UINT32 Width) 1076{ 1077 1078 switch (Width) 1079 { 1080 case 8: 1081 1082 *Value = 0xFF; 1083 break; 1084 1085 case 16: 1086 1087 *Value = 0xFFFF; 1088 break; 1089 1090 case 32: 1091 1092 *Value = 0xFFFFFFFF; 1093 break; 1094 1095 default: 1096 1097 return (AE_BAD_PARAMETER); 1098 } 1099 1100 return (AE_OK); 1101} 1102 1103 1104/****************************************************************************** 1105 * 1106 * FUNCTION: AcpiOsWritePort 1107 * 1108 * PARAMETERS: Address - Address of I/O port/register to write 1109 * Value - Value to write 1110 * Width - Number of bits 1111 * 1112 * RETURN: None 1113 * 1114 * DESCRIPTION: Write data to an I/O port or register 1115 * 1116 *****************************************************************************/ 1117 1118ACPI_STATUS 1119AcpiOsWritePort ( 1120 ACPI_IO_ADDRESS Address, 1121 UINT32 Value, 1122 UINT32 Width) 1123{ 1124 1125 return (AE_OK); 1126} 1127 1128 1129/****************************************************************************** 1130 * 1131 * FUNCTION: AcpiOsReadMemory 1132 * 1133 * PARAMETERS: Address - Physical Memory Address to read 1134 * Value - Where value is placed 1135 * Width - Number of bits (8,16,32, or 64) 1136 * 1137 * RETURN: Value read from physical memory address. Always returned 1138 * as a 64-bit integer, regardless of the read width. 1139 * 1140 * DESCRIPTION: Read data from a physical memory address 1141 * 1142 *****************************************************************************/ 1143 1144ACPI_STATUS 1145AcpiOsReadMemory ( 1146 ACPI_PHYSICAL_ADDRESS Address, 1147 UINT64 *Value, 1148 UINT32 Width) 1149{ 1150 1151 switch (Width) 1152 { 1153 case 8: 1154 case 16: 1155 case 32: 1156 case 64: 1157 1158 *Value = 0; 1159 break; 1160 1161 default: 1162 1163 return (AE_BAD_PARAMETER); 1164 } 1165 return (AE_OK); 1166} 1167 1168 1169/****************************************************************************** 1170 * 1171 * FUNCTION: AcpiOsWriteMemory 1172 * 1173 * PARAMETERS: Address - Physical Memory Address to write 1174 * Value - Value to write 1175 * Width - Number of bits (8,16,32, or 64) 1176 * 1177 * RETURN: None 1178 * 1179 * DESCRIPTION: Write data to a physical memory address 1180 * 1181 *****************************************************************************/ 1182 1183ACPI_STATUS 1184AcpiOsWriteMemory ( 1185 ACPI_PHYSICAL_ADDRESS Address, 1186 UINT64 Value, 1187 UINT32 Width) 1188{ 1189 1190 return (AE_OK); 1191} 1192 1193 1194/****************************************************************************** 1195 * 1196 * FUNCTION: AcpiOsReadable 1197 * 1198 * PARAMETERS: Pointer - Area to be verified 1199 * Length - Size of area 1200 * 1201 * RETURN: TRUE if readable for entire length 1202 * 1203 * DESCRIPTION: Verify that a pointer is valid for reading 1204 * 1205 *****************************************************************************/ 1206 1207BOOLEAN 1208AcpiOsReadable ( 1209 void *Pointer, 1210 ACPI_SIZE Length) 1211{ 1212 1213 return (TRUE); 1214} 1215 1216 1217/****************************************************************************** 1218 * 1219 * FUNCTION: AcpiOsWritable 1220 * 1221 * PARAMETERS: Pointer - Area to be verified 1222 * Length - Size of area 1223 * 1224 * RETURN: TRUE if writable for entire length 1225 * 1226 * DESCRIPTION: Verify that a pointer is valid for writing 1227 * 1228 *****************************************************************************/ 1229 1230BOOLEAN 1231AcpiOsWritable ( 1232 void *Pointer, 1233 ACPI_SIZE Length) 1234{ 1235 1236 return (TRUE); 1237} 1238 1239 1240/****************************************************************************** 1241 * 1242 * FUNCTION: AcpiOsSignal 1243 * 1244 * PARAMETERS: Function - ACPI CA signal function code 1245 * Info - Pointer to function-dependent structure 1246 * 1247 * RETURN: Status 1248 * 1249 * DESCRIPTION: Miscellaneous functions. Example implementation only. 1250 * 1251 *****************************************************************************/ 1252 1253ACPI_STATUS 1254AcpiOsSignal ( 1255 UINT32 Function, 1256 void *Info) 1257{ 1258 1259 switch (Function) 1260 { 1261 case ACPI_SIGNAL_FATAL: 1262 1263 break; 1264 1265 case ACPI_SIGNAL_BREAKPOINT: 1266 1267 break; 1268 1269 default: 1270 1271 break; 1272 } 1273 1274 return (AE_OK); 1275} 1276 1277/* Optional multi-thread support */ 1278 1279#ifndef ACPI_SINGLE_THREADED 1280/****************************************************************************** 1281 * 1282 * FUNCTION: AcpiOsGetThreadId 1283 * 1284 * PARAMETERS: None 1285 * 1286 * RETURN: Id of the running thread 1287 * 1288 * DESCRIPTION: Get the ID of the current (running) thread 1289 * 1290 *****************************************************************************/ 1291 1292ACPI_THREAD_ID 1293AcpiOsGetThreadId ( 1294 void) 1295{ 1296 pthread_t thread; 1297 1298 1299 thread = pthread_self(); 1300 return (ACPI_CAST_PTHREAD_T (thread)); 1301} 1302 1303 1304/****************************************************************************** 1305 * 1306 * FUNCTION: AcpiOsExecute 1307 * 1308 * PARAMETERS: Type - Type of execution 1309 * Function - Address of the function to execute 1310 * Context - Passed as a parameter to the function 1311 * 1312 * RETURN: Status. 1313 * 1314 * DESCRIPTION: Execute a new thread 1315 * 1316 *****************************************************************************/ 1317 1318ACPI_STATUS 1319AcpiOsExecute ( 1320 ACPI_EXECUTE_TYPE Type, 1321 ACPI_OSD_EXEC_CALLBACK Function, 1322 void *Context) 1323{ 1324 pthread_t thread; 1325 int ret; 1326 1327 1328 ret = pthread_create (&thread, NULL, (PTHREAD_CALLBACK) Function, Context); 1329 if (ret) 1330 { 1331 AcpiOsPrintf("Create thread failed"); 1332 } 1333 return (0); 1334} 1335 1336#endif /* ACPI_SINGLE_THREADED */ 1337 1338 1339/****************************************************************************** 1340 * 1341 * FUNCTION: AcpiOsWaitEventsComplete 1342 * 1343 * PARAMETERS: None 1344 * 1345 * RETURN: None 1346 * 1347 * DESCRIPTION: Wait for all asynchronous events to complete. This 1348 * implementation does nothing. 1349 * 1350 *****************************************************************************/ 1351 1352void 1353AcpiOsWaitEventsComplete ( 1354 void) 1355{ 1356 return; 1357} 1358