OSCL-LXR linux-6.0.1/​tools/​power/​acpi/​os_specific/​service_layers/​osunixxf.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
 /******************************************************************************
  *
  * Module Name: osunixxf - UNIX OSL interfaces
  *
  * Copyright (C) 2000 - 2022, Intel Corp.
  *
  *****************************************************************************/
 
 /*
  * These interfaces are required in order to compile the ASL compiler and the
  * various ACPICA tools under Linux or other Unix-like system.
  */
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "amlcode.h"
 #include "acparser.h"
 #include "acdebug.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <semaphore.h>
 #include <pthread.h>
 #include <errno.h>
 
 #define _COMPONENT          ACPI_OS_SERVICES
 ACPI_MODULE_NAME("osunixxf")
 
 /* Upcalls to acpi_exec */
 void
 ae_table_override(struct acpi_table_header *existing_table,
           struct acpi_table_header **new_table);
 
 typedef void *(*PTHREAD_CALLBACK) (void *);
 
 /* Buffer used by acpi_os_vprintf */
 
 #define ACPI_VPRINTF_BUFFER_SIZE    512
 #define _ASCII_NEWLINE              '\n'
 
 /* Terminal support for acpi_exec only */
 
 #ifdef ACPI_EXEC_APP
 #include <termios.h>
 
 struct termios original_term_attributes;
 int term_attributes_were_set = 0;
 
 acpi_status acpi_ut_read_line(char *buffer, u32 buffer_length, u32 *bytes_read);
 
 static void os_enter_line_edit_mode(void);
 
 static void os_exit_line_edit_mode(void);
 
 /******************************************************************************
  *
  * FUNCTION:    os_enter_line_edit_mode, os_exit_line_edit_mode
  *
  * PARAMETERS:  None
  *
  * RETURN:      None
  *
  * DESCRIPTION: Enter/Exit the raw character input mode for the terminal.
  *
  * Interactive line-editing support for the AML debugger. Used with the
  * common/acgetline module.
  *
  * readline() is not used because of non-portability. It is not available
  * on all systems, and if it is, often the package must be manually installed.
  *
  * Therefore, we use the POSIX tcgetattr/tcsetattr and do the minimal line
  * editing that we need in acpi_os_get_line.
  *
  * If the POSIX tcgetattr/tcsetattr interfaces are unavailable, these
  * calls will also work:
  *     For os_enter_line_edit_mode: system ("stty cbreak -echo")
  *     For os_exit_line_edit_mode: system ("stty cooked echo")
  *
  *****************************************************************************/
 
 static void os_enter_line_edit_mode(void)
 {
     struct termios local_term_attributes;
 
     term_attributes_were_set = 0;
 
     /* STDIN must be a terminal */
 
     if (!isatty(STDIN_FILENO)) {
         return;
     }
 
     /* Get and keep the original attributes */
 
     if (tcgetattr(STDIN_FILENO, &original_term_attributes)) {
         fprintf(stderr, "Could not get terminal attributes!\n");
         return;
     }
 
     /* Set the new attributes to enable raw character input */
 
     memcpy(&local_term_attributes, &original_term_attributes,
            sizeof(struct termios));
 
     local_term_attributes.c_lflag &= ~(ICANON | ECHO);
     local_term_attributes.c_cc[VMIN] = 1;
     local_term_attributes.c_cc[VTIME] = 0;
 
     if (tcsetattr(STDIN_FILENO, TCSANOW, &local_term_attributes)) {
         fprintf(stderr, "Could not set terminal attributes!\n");
         return;
     }
 
     term_attributes_were_set = 1;
 }
 
 static void os_exit_line_edit_mode(void)
 {
 
     if (!term_attributes_were_set) {
         return;
     }
 
     /* Set terminal attributes back to the original values */
 
     if (tcsetattr(STDIN_FILENO, TCSANOW, &original_term_attributes)) {
         fprintf(stderr, "Could not restore terminal attributes!\n");
     }
 }
 
 #else
 
 /* These functions are not needed for other ACPICA utilities */
 
 #define os_enter_line_edit_mode()
 #define os_exit_line_edit_mode()
 #endif
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_initialize, acpi_os_terminate
  *
  * PARAMETERS:  None
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Initialize and terminate this module.
  *
  *****************************************************************************/
 
 acpi_status acpi_os_initialize(void)
 {
     acpi_status status;
 
     acpi_gbl_output_file = stdout;
 
     os_enter_line_edit_mode();
 
     status = acpi_os_create_lock(&acpi_gbl_print_lock);
     if (ACPI_FAILURE(status)) {
         return (status);
     }
 
     return (AE_OK);
 }
 
 acpi_status acpi_os_terminate(void)
 {
 
     os_exit_line_edit_mode();
     return (AE_OK);
 }
 
 #ifndef ACPI_USE_NATIVE_RSDP_POINTER
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_get_root_pointer
  *
  * PARAMETERS:  None
  *
  * RETURN:      RSDP physical address
  *
  * DESCRIPTION: Gets the ACPI root pointer (RSDP)
  *
  *****************************************************************************/
 
 acpi_physical_address acpi_os_get_root_pointer(void)
 {
 
     return (0);
 }
 #endif
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_predefined_override
  *
  * PARAMETERS:  init_val            - Initial value of the predefined object
  *              new_val             - The new value for the object
  *
  * RETURN:      Status, pointer to value. Null pointer returned if not
  *              overriding.
  *
  * DESCRIPTION: Allow the OS to override predefined names
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
                 acpi_string *new_val)
 {
 
     if (!init_val || !new_val) {
         return (AE_BAD_PARAMETER);
     }
 
     *new_val = NULL;
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_table_override
  *
  * PARAMETERS:  existing_table      - Header of current table (probably
  *                                    firmware)
  *              new_table           - Where an entire new table is returned.
  *
  * RETURN:      Status, pointer to new table. Null pointer returned if no
  *              table is available to override
  *
  * DESCRIPTION: Return a different version of a table if one is available
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_table_override(struct acpi_table_header *existing_table,
                struct acpi_table_header **new_table)
 {
 
     if (!existing_table || !new_table) {
         return (AE_BAD_PARAMETER);
     }
 
     *new_table = NULL;
 
 #ifdef ACPI_EXEC_APP
 
     ae_table_override(existing_table, new_table);
     return (AE_OK);
 #else
 
     return (AE_NO_ACPI_TABLES);
 #endif
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_physical_table_override
  *
  * PARAMETERS:  existing_table      - Header of current table (probably firmware)
  *              new_address         - Where new table address is returned
  *                                    (Physical address)
  *              new_table_length    - Where new table length is returned
  *
  * RETURN:      Status, address/length of new table. Null pointer returned
  *              if no table is available to override.
  *
  * DESCRIPTION: Returns AE_SUPPORT, function not used in user space.
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_physical_table_override(struct acpi_table_header *existing_table,
                 acpi_physical_address *new_address,
                 u32 *new_table_length)
 {
 
     return (AE_SUPPORT);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_enter_sleep
  *
  * PARAMETERS:  sleep_state         - Which sleep state to enter
  *              rega_value          - Register A value
  *              regb_value          - Register B value
  *
  * RETURN:      Status
  *
  * DESCRIPTION: A hook before writing sleep registers to enter the sleep
  *              state. Return AE_CTRL_TERMINATE to skip further sleep register
  *              writes.
  *
  *****************************************************************************/
 
 acpi_status acpi_os_enter_sleep(u8 sleep_state, u32 rega_value, u32 regb_value)
 {
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_redirect_output
  *
  * PARAMETERS:  destination         - An open file handle/pointer
  *
  * RETURN:      None
  *
  * DESCRIPTION: Causes redirect of acpi_os_printf and acpi_os_vprintf
  *
  *****************************************************************************/
 
 void acpi_os_redirect_output(void *destination)
 {
 
     acpi_gbl_output_file = destination;
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_printf
  *
  * PARAMETERS:  fmt, ...            - Standard printf format
  *
  * RETURN:      None
  *
  * DESCRIPTION: Formatted output. Note: very similar to acpi_os_vprintf
  *              (performance), changes should be tracked in both functions.
  *
  *****************************************************************************/
 
 void ACPI_INTERNAL_VAR_XFACE acpi_os_printf(const char *fmt, ...)
 {
     va_list args;
     u8 flags;
 
     flags = acpi_gbl_db_output_flags;
     if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
 
         /* Output is directable to either a file (if open) or the console */
 
         if (acpi_gbl_debug_file) {
 
             /* Output file is open, send the output there */
 
             va_start(args, fmt);
             vfprintf(acpi_gbl_debug_file, fmt, args);
             va_end(args);
         } else {
             /* No redirection, send output to console (once only!) */
 
             flags |= ACPI_DB_CONSOLE_OUTPUT;
         }
     }
 
     if (flags & ACPI_DB_CONSOLE_OUTPUT) {
         va_start(args, fmt);
         vfprintf(acpi_gbl_output_file, fmt, args);
         va_end(args);
     }
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_vprintf
  *
  * PARAMETERS:  fmt                 - Standard printf format
  *              args                - Argument list
  *
  * RETURN:      None
  *
  * DESCRIPTION: Formatted output with argument list pointer. Note: very
  *              similar to acpi_os_printf, changes should be tracked in both
  *              functions.
  *
  *****************************************************************************/
 
 void acpi_os_vprintf(const char *fmt, va_list args)
 {
     u8 flags;
     char buffer[ACPI_VPRINTF_BUFFER_SIZE];
 
     /*
      * We build the output string in a local buffer because we may be
      * outputting the buffer twice. Using vfprintf is problematic because
      * some implementations modify the args pointer/structure during
      * execution. Thus, we use the local buffer for portability.
      *
      * Note: Since this module is intended for use by the various ACPICA
      * utilities/applications, we can safely declare the buffer on the stack.
      * Also, This function is used for relatively small error messages only.
      */
     vsnprintf(buffer, ACPI_VPRINTF_BUFFER_SIZE, fmt, args);
 
     flags = acpi_gbl_db_output_flags;
     if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
 
         /* Output is directable to either a file (if open) or the console */
 
         if (acpi_gbl_debug_file) {
 
             /* Output file is open, send the output there */
 
             fputs(buffer, acpi_gbl_debug_file);
         } else {
             /* No redirection, send output to console (once only!) */
 
             flags |= ACPI_DB_CONSOLE_OUTPUT;
         }
     }
 
     if (flags & ACPI_DB_CONSOLE_OUTPUT) {
         fputs(buffer, acpi_gbl_output_file);
     }
 }
 
 #ifndef ACPI_EXEC_APP
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_get_line
  *
  * PARAMETERS:  buffer              - Where to return the command line
  *              buffer_length       - Maximum length of Buffer
  *              bytes_read          - Where the actual byte count is returned
  *
  * RETURN:      Status and actual bytes read
  *
  * DESCRIPTION: Get the next input line from the terminal. NOTE: For the
  *              acpi_exec utility, we use the acgetline module instead to
  *              provide line-editing and history support.
  *
  *****************************************************************************/
 
 acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read)
 {
     int input_char;
     u32 end_of_line;
 
     /* Standard acpi_os_get_line for all utilities except acpi_exec */
 
     for (end_of_line = 0;; end_of_line++) {
         if (end_of_line >= buffer_length) {
             return (AE_BUFFER_OVERFLOW);
         }
 
         if ((input_char = getchar()) == EOF) {
             return (AE_ERROR);
         }
 
         if (!input_char || input_char == _ASCII_NEWLINE) {
             break;
         }
 
         buffer[end_of_line] = (char)input_char;
     }
 
     /* Null terminate the buffer */
 
     buffer[end_of_line] = 0;
 
     /* Return the number of bytes in the string */
 
     if (bytes_read) {
         *bytes_read = end_of_line;
     }
 
     return (AE_OK);
 }
 #endif
 
 #ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_map_memory
  *
  * PARAMETERS:  where               - Physical address of memory to be mapped
  *              length              - How much memory to map
  *
  * RETURN:      Pointer to mapped memory. Null on error.
  *
  * DESCRIPTION: Map physical memory into caller's address space
  *
  *****************************************************************************/
 
 void *acpi_os_map_memory(acpi_physical_address where, acpi_size length)
 {
 
     return (ACPI_TO_POINTER((acpi_size)where));
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_unmap_memory
  *
  * PARAMETERS:  where               - Logical address of memory to be unmapped
  *              length              - How much memory to unmap
  *
  * RETURN:      None.
  *
  * DESCRIPTION: Delete a previously created mapping. Where and Length must
  *              correspond to a previous mapping exactly.
  *
  *****************************************************************************/
 
 void acpi_os_unmap_memory(void *where, acpi_size length)
 {
 
     return;
 }
 #endif
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_allocate
  *
  * PARAMETERS:  size                - Amount to allocate, in bytes
  *
  * RETURN:      Pointer to the new allocation. Null on error.
  *
  * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
  *
  *****************************************************************************/
 
 void *acpi_os_allocate(acpi_size size)
 {
     void *mem;
 
     mem = (void *)malloc((size_t) size);
     return (mem);
 }
 
 #ifdef USE_NATIVE_ALLOCATE_ZEROED
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_allocate_zeroed
  *
  * PARAMETERS:  size                - Amount to allocate, in bytes
  *
  * RETURN:      Pointer to the new allocation. Null on error.
  *
  * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
  *
  *****************************************************************************/
 
 void *acpi_os_allocate_zeroed(acpi_size size)
 {
     void *mem;
 
     mem = (void *)calloc(1, (size_t) size);
     return (mem);
 }
 #endif
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_free
  *
  * PARAMETERS:  mem                 - Pointer to previously allocated memory
  *
  * RETURN:      None.
  *
  * DESCRIPTION: Free memory allocated via acpi_os_allocate
  *
  *****************************************************************************/
 
 void acpi_os_free(void *mem)
 {
 
     free(mem);
 }
 
 #ifdef ACPI_SINGLE_THREADED
 /******************************************************************************
  *
  * FUNCTION:    Semaphore stub functions
  *
  * DESCRIPTION: Stub functions used for single-thread applications that do
  *              not require semaphore synchronization. Full implementations
  *              of these functions appear after the stubs.
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_create_semaphore(u32 max_units,
              u32 initial_units, acpi_handle *out_handle)
 {
     *out_handle = (acpi_handle)1;
     return (AE_OK);
 }
 
 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
 {
     return (AE_OK);
 }
 
 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
 {
     return (AE_OK);
 }
 
 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 {
     return (AE_OK);
 }
 
 #else
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_create_semaphore
  *
  * PARAMETERS:  initial_units       - Units to be assigned to the new semaphore
  *              out_handle          - Where a handle will be returned
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Create an OS semaphore
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_create_semaphore(u32 max_units,
              u32 initial_units, acpi_handle *out_handle)
 {
     sem_t *sem;
 
     if (!out_handle) {
         return (AE_BAD_PARAMETER);
     }
 #ifdef __APPLE__
     {
         static int semaphore_count = 0;
         char semaphore_name[32];
 
         snprintf(semaphore_name, sizeof(semaphore_name), "acpi_sem_%d",
              semaphore_count++);
         printf("%s\n", semaphore_name);
         sem =
             sem_open(semaphore_name, O_EXCL | O_CREAT, 0755,
                  initial_units);
         if (!sem) {
             return (AE_NO_MEMORY);
         }
         sem_unlink(semaphore_name); /* This just deletes the name */
     }
 
 #else
     sem = acpi_os_allocate(sizeof(sem_t));
     if (!sem) {
         return (AE_NO_MEMORY);
     }
 
     if (sem_init(sem, 0, initial_units) == -1) {
         acpi_os_free(sem);
         return (AE_BAD_PARAMETER);
     }
 #endif
 
     *out_handle = (acpi_handle)sem;
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_delete_semaphore
  *
  * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Delete an OS semaphore
  *
  *****************************************************************************/
 
 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
 {
     sem_t *sem = (sem_t *) handle;
 
     if (!sem) {
         return (AE_BAD_PARAMETER);
     }
 #ifdef __APPLE__
     if (sem_close(sem) == -1) {
         return (AE_BAD_PARAMETER);
     }
 #else
     if (sem_destroy(sem) == -1) {
         return (AE_BAD_PARAMETER);
     }
 #endif
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_wait_semaphore
  *
  * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
  *              units               - How many units to wait for
  *              msec_timeout        - How long to wait (milliseconds)
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Wait for units
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 msec_timeout)
 {
     acpi_status status = AE_OK;
     sem_t *sem = (sem_t *) handle;
     int ret_val;
 #ifndef ACPI_USE_ALTERNATE_TIMEOUT
     struct timespec time;
 #endif
 
     if (!sem) {
         return (AE_BAD_PARAMETER);
     }
 
     switch (msec_timeout) {
         /*
          * No Wait:
          * --------
          * A zero timeout value indicates that we shouldn't wait - just
          * acquire the semaphore if available otherwise return AE_TIME
          * (a.k.a. 'would block').
          */
     case 0:
 
         if (sem_trywait(sem) == -1) {
             status = (AE_TIME);
         }
         break;
 
         /* Wait Indefinitely */
 
     case ACPI_WAIT_FOREVER:
 
         while (((ret_val = sem_wait(sem)) == -1) && (errno == EINTR)) {
             continue;   /* Restart if interrupted */
         }
         if (ret_val != 0) {
             status = (AE_TIME);
         }
         break;
 
         /* Wait with msec_timeout */
 
     default:
 
 #ifdef ACPI_USE_ALTERNATE_TIMEOUT
         /*
          * Alternate timeout mechanism for environments where
          * sem_timedwait is not available or does not work properly.
          */
         while (msec_timeout) {
             if (sem_trywait(sem) == 0) {
 
                 /* Got the semaphore */
                 return (AE_OK);
             }
 
             if (msec_timeout >= 10) {
                 msec_timeout -= 10;
                 usleep(10 * ACPI_USEC_PER_MSEC);    /* ten milliseconds */
             } else {
                 msec_timeout--;
                 usleep(ACPI_USEC_PER_MSEC); /* one millisecond */
             }
         }
         status = (AE_TIME);
 #else
         /*
          * The interface to sem_timedwait is an absolute time, so we need to
          * get the current time, then add in the millisecond Timeout value.
          */
         if (clock_gettime(CLOCK_REALTIME, &time) == -1) {
             perror("clock_gettime");
             return (AE_TIME);
         }
 
         time.tv_sec += (msec_timeout / ACPI_MSEC_PER_SEC);
         time.tv_nsec +=
             ((msec_timeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC);
 
         /* Handle nanosecond overflow (field must be less than one second) */
 
         if (time.tv_nsec >= ACPI_NSEC_PER_SEC) {
             time.tv_sec += (time.tv_nsec / ACPI_NSEC_PER_SEC);
             time.tv_nsec = (time.tv_nsec % ACPI_NSEC_PER_SEC);
         }
 
         while (((ret_val = sem_timedwait(sem, &time)) == -1)
                && (errno == EINTR)) {
             continue;   /* Restart if interrupted */
 
         }
 
         if (ret_val != 0) {
             if (errno != ETIMEDOUT) {
                 perror("sem_timedwait");
             }
             status = (AE_TIME);
         }
 #endif
         break;
     }
 
     return (status);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_signal_semaphore
  *
  * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
  *              units               - Number of units to send
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Send units
  *
  *****************************************************************************/
 
 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 {
     sem_t *sem = (sem_t *) handle;
 
     if (!sem) {
         return (AE_BAD_PARAMETER);
     }
 
     if (sem_post(sem) == -1) {
         return (AE_LIMIT);
     }
 
     return (AE_OK);
 }
 
 #endif              /* ACPI_SINGLE_THREADED */
 
 /******************************************************************************
  *
  * FUNCTION:    Spinlock interfaces
  *
  * DESCRIPTION: Map these interfaces to semaphore interfaces
  *
  *****************************************************************************/
 
 acpi_status acpi_os_create_lock(acpi_spinlock * out_handle)
 {
 
     return (acpi_os_create_semaphore(1, 1, out_handle));
 }
 
 void acpi_os_delete_lock(acpi_spinlock handle)
 {
     acpi_os_delete_semaphore(handle);
 }
 
 acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle)
 {
     acpi_os_wait_semaphore(handle, 1, 0xFFFF);
     return (0);
 }
 
 void acpi_os_release_lock(acpi_spinlock handle, acpi_cpu_flags flags)
 {
     acpi_os_signal_semaphore(handle, 1);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_install_interrupt_handler
  *
  * PARAMETERS:  interrupt_number    - Level handler should respond to.
  *              isr                 - Address of the ACPI interrupt handler
  *              except_ptr          - Where status is returned
  *
  * RETURN:      Handle to the newly installed handler.
  *
  * DESCRIPTION: Install an interrupt handler. Used to install the ACPI
  *              OS-independent handler.
  *
  *****************************************************************************/
 
 u32
 acpi_os_install_interrupt_handler(u32 interrupt_number,
                   acpi_osd_handler service_routine,
                   void *context)
 {
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_remove_interrupt_handler
  *
  * PARAMETERS:  handle              - Returned when handler was installed
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Uninstalls an interrupt handler.
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_remove_interrupt_handler(u32 interrupt_number,
                  acpi_osd_handler service_routine)
 {
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_stall
  *
  * PARAMETERS:  microseconds        - Time to sleep
  *
  * RETURN:      Blocks until sleep is completed.
  *
  * DESCRIPTION: Sleep at microsecond granularity
  *
  *****************************************************************************/
 
 void acpi_os_stall(u32 microseconds)
 {
 
     if (microseconds) {
         usleep(microseconds);
     }
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_sleep
  *
  * PARAMETERS:  milliseconds        - Time to sleep
  *
  * RETURN:      Blocks until sleep is completed.
  *
  * DESCRIPTION: Sleep at millisecond granularity
  *
  *****************************************************************************/
 
 void acpi_os_sleep(u64 milliseconds)
 {
 
     /* Sleep for whole seconds */
 
     sleep(milliseconds / ACPI_MSEC_PER_SEC);
 
     /*
      * Sleep for remaining microseconds.
      * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second).
      */
     usleep((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_get_timer
  *
  * PARAMETERS:  None
  *
  * RETURN:      Current time in 100 nanosecond units
  *
  * DESCRIPTION: Get the current system time
  *
  *****************************************************************************/
 
 u64 acpi_os_get_timer(void)
 {
     struct timeval time;
 
     /* This timer has sufficient resolution for user-space application code */
 
     gettimeofday(&time, NULL);
 
     /* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */
 
     return (((u64)time.tv_sec * ACPI_100NSEC_PER_SEC) +
         ((u64)time.tv_usec * ACPI_100NSEC_PER_USEC));
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_read_pci_configuration
  *
  * PARAMETERS:  pci_id              - Seg/Bus/Dev
  *              pci_register        - Device Register
  *              value               - Buffer where value is placed
  *              width               - Number of bits
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Read data from PCI configuration space
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id,
                    u32 pci_register, u64 *value, u32 width)
 {
 
     *value = 0;
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_write_pci_configuration
  *
  * PARAMETERS:  pci_id              - Seg/Bus/Dev
  *              pci_register        - Device Register
  *              value               - Value to be written
  *              width               - Number of bits
  *
  * RETURN:      Status.
  *
  * DESCRIPTION: Write data to PCI configuration space
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_write_pci_configuration(struct acpi_pci_id *pci_id,
                 u32 pci_register, u64 value, u32 width)
 {
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_read_port
  *
  * PARAMETERS:  address             - Address of I/O port/register to read
  *              value               - Where value is placed
  *              width               - Number of bits
  *
  * RETURN:      Value read from port
  *
  * DESCRIPTION: Read data from an I/O port or register
  *
  *****************************************************************************/
 
 acpi_status acpi_os_read_port(acpi_io_address address, u32 *value, u32 width)
 {
 
     switch (width) {
     case 8:
 
         *value = 0xFF;
         break;
 
     case 16:
 
         *value = 0xFFFF;
         break;
 
     case 32:
 
         *value = 0xFFFFFFFF;
         break;
 
     default:
 
         return (AE_BAD_PARAMETER);
     }
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_write_port
  *
  * PARAMETERS:  address             - Address of I/O port/register to write
  *              value               - Value to write
  *              width               - Number of bits
  *
  * RETURN:      None
  *
  * DESCRIPTION: Write data to an I/O port or register
  *
  *****************************************************************************/
 
 acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width)
 {
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_read_memory
  *
  * PARAMETERS:  address             - Physical Memory Address to read
  *              value               - Where value is placed
  *              width               - Number of bits (8,16,32, or 64)
  *
  * RETURN:      Value read from physical memory address. Always returned
  *              as a 64-bit integer, regardless of the read width.
  *
  * DESCRIPTION: Read data from a physical memory address
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width)
 {
 
     switch (width) {
     case 8:
     case 16:
     case 32:
     case 64:
 
         *value = 0;
         break;
 
     default:
 
         return (AE_BAD_PARAMETER);
     }
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_write_memory
  *
  * PARAMETERS:  address             - Physical Memory Address to write
  *              value               - Value to write
  *              width               - Number of bits (8,16,32, or 64)
  *
  * RETURN:      None
  *
  * DESCRIPTION: Write data to a physical memory address
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_write_memory(acpi_physical_address address, u64 value, u32 width)
 {
 
     return (AE_OK);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_readable
  *
  * PARAMETERS:  pointer             - Area to be verified
  *              length              - Size of area
  *
  * RETURN:      TRUE if readable for entire length
  *
  * DESCRIPTION: Verify that a pointer is valid for reading
  *
  *****************************************************************************/
 
 u8 acpi_os_readable(void *pointer, acpi_size length)
 {
 
     return (TRUE);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_writable
  *
  * PARAMETERS:  pointer             - Area to be verified
  *              length              - Size of area
  *
  * RETURN:      TRUE if writable for entire length
  *
  * DESCRIPTION: Verify that a pointer is valid for writing
  *
  *****************************************************************************/
 
 u8 acpi_os_writable(void *pointer, acpi_size length)
 {
 
     return (TRUE);
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_signal
  *
  * PARAMETERS:  function            - ACPI A signal function code
  *              info                - Pointer to function-dependent structure
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Miscellaneous functions. Example implementation only.
  *
  *****************************************************************************/
 
 acpi_status acpi_os_signal(u32 function, void *info)
 {
 
     switch (function) {
     case ACPI_SIGNAL_FATAL:
 
         break;
 
     case ACPI_SIGNAL_BREAKPOINT:
 
         break;
 
     default:
 
         break;
     }
 
     return (AE_OK);
 }
 
 /* Optional multi-thread support */
 
 #ifndef ACPI_SINGLE_THREADED
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_get_thread_id
  *
  * PARAMETERS:  None
  *
  * RETURN:      Id of the running thread
  *
  * DESCRIPTION: Get the ID of the current (running) thread
  *
  *****************************************************************************/
 
 acpi_thread_id acpi_os_get_thread_id(void)
 {
     pthread_t thread;
 
     thread = pthread_self();
     return (ACPI_CAST_PTHREAD_T(thread));
 }
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_execute
  *
  * PARAMETERS:  type                - Type of execution
  *              function            - Address of the function to execute
  *              context             - Passed as a parameter to the function
  *
  * RETURN:      Status.
  *
  * DESCRIPTION: Execute a new thread
  *
  *****************************************************************************/
 
 acpi_status
 acpi_os_execute(acpi_execute_type type,
         acpi_osd_exec_callback function, void *context)
 {
     pthread_t thread;
     int ret;
 
     ret =
         pthread_create(&thread, NULL, (PTHREAD_CALLBACK) function, context);
     if (ret) {
         acpi_os_printf("Create thread failed");
     }
     return (0);
 }
 
 #else               /* ACPI_SINGLE_THREADED */
 acpi_thread_id acpi_os_get_thread_id(void)
 {
     return (1);
 }
 
 acpi_status
 acpi_os_execute(acpi_execute_type type,
         acpi_osd_exec_callback function, void *context)
 {
 
     function(context);
 
     return (AE_OK);
 }
 
 #endif              /* ACPI_SINGLE_THREADED */
 
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_wait_events_complete
  *
  * PARAMETERS:  None
  *
  * RETURN:      None
  *
  * DESCRIPTION: Wait for all asynchronous events to complete. This
  *              implementation does nothing.
  *
  *****************************************************************************/
 
 void acpi_os_wait_events_complete(void)
 {
     return;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team