forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1317 lines
32 KiB
1317 lines
32 KiB
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
|
/****************************************************************************** |
|
* |
|
* Module Name: osunixxf - UNIX OSL interfaces |
|
* |
|
* Copyright (C) 2000 - 2021, 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; |
|
}
|
|
|