nathan/CoolPi-Armbian-Rockchip-RK3588-Upstream-Linux-6.1-LTS-Kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CoolPi-Armbian-Rockchip-RK3.../tools/power/acpi/os_specific/service_layers/osunixxf.c

1318 lines
32 KiB
C
Raw Blame History

// 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;
}
Reference in New Issue View Git Blame Copy Permalink