i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* More cleanup, made the coding style mostly Haiku compliant, replaced space

Browse Source 
by tab indents everywhere.
* Remove special handling in map_physical_memory to handle page offset and
  length. Opposed to BeOS, Haiku does both automatically.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28091 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Michael Lotz
2008-10-14 15:20:03 +00:00
parent 1627a0251e
commit 4476b88f81
1 changed files with 336 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/bus_managers/acpi/oshaiku.c
+64 -168
View File
@@ -144,7 +144,6 @@ extern void *gDPCHandle;
#define _COMPONENT ACPI_OS_SERVICES #define _COMPONENT ACPI_OS_SERVICES
ACPI_MODULE_NAME ("oshaiku") ACPI_MODULE_NAME ("oshaiku")
extern FILE * AcpiGbl_DebugFile; extern FILE * AcpiGbl_DebugFile;
FILE * AcpiGbl_OutputFile; FILE * AcpiGbl_OutputFile;
@@ -171,7 +170,6 @@ AcpiOsInitialize (void)
#else #else
AcpiGbl_OutputFile = NULL; AcpiGbl_OutputFile = NULL;
#endif #endif
return AE_OK; return AE_OK;
} }
@@ -230,17 +228,14 @@ AcpiOsGetRootPointer (void)
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsPredefinedOverride ( AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES *InitVal,
const ACPI_PREDEFINED_NAMES *InitVal,
ACPI_STRING *NewVal) ACPI_STRING *NewVal)
{ {
if (!InitVal || !NewVal) if (!InitVal || !NewVal)
{ return AE_BAD_PARAMETER;
return (AE_BAD_PARAMETER);
}
*NewVal = NULL; *NewVal = NULL;
return (AE_OK); return AE_OK;
} }
@@ -259,28 +254,22 @@ AcpiOsPredefinedOverride (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsTableOverride ( AcpiOsTableOverride(ACPI_TABLE_HEADER *ExistingTable,
ACPI_TABLE_HEADER *ExistingTable,
ACPI_TABLE_HEADER **NewTable) ACPI_TABLE_HEADER **NewTable)
{ {
if (!ExistingTable || !NewTable) if (!ExistingTable || !NewTable)
{ return AE_BAD_PARAMETER;
return (AE_BAD_PARAMETER);
}
*NewTable = NULL; *NewTable = NULL;
#ifdef _ACPI_EXEC_APP #ifdef _ACPI_EXEC_APP
/* This code exercises the table override mechanism in the core */ /* This code exercises the table override mechanism in the core */
if (!ACPI_STRNCMP(ExistingTable->Signature, DSDT_SIG, ACPI_NAME_SIZE)) {
if (!ACPI_STRNCMP (ExistingTable->Signature, DSDT_SIG, ACPI_NAME_SIZE))
{
/* override DSDT with itself */ /* override DSDT with itself */
*NewTable = AcpiGbl_DbTablePtr; *NewTable = AcpiGbl_DbTablePtr;
} }
return (AE_OK);
return AE_OK;
#else #else
return AE_NO_ACPI_TABLES; return AE_NO_ACPI_TABLES;
#endif #endif
@@ -301,9 +290,7 @@ AcpiOsTableOverride (
*****************************************************************************/ *****************************************************************************/
BOOLEAN BOOLEAN
AcpiOsReadable ( AcpiOsReadable(void *Pointer, ACPI_SIZE Length)
void *Pointer,
ACPI_SIZE Length)
{ {
return TRUE; return TRUE;
} }
@@ -323,9 +310,7 @@ AcpiOsReadable (
*****************************************************************************/ *****************************************************************************/
BOOLEAN BOOLEAN
AcpiOsWritable ( AcpiOsWritable(void *Pointer, ACPI_SIZE Length)
void *Pointer,
ACPI_SIZE Length)
{ {
return TRUE; return TRUE;
} }
@@ -335,7 +320,7 @@ AcpiOsWritable (
* *
* FUNCTION: AcpiOsRedirectOutput * FUNCTION: AcpiOsRedirectOutput
* *
* PARAMETERS: Destination - An open file handle/pointer * PARAMETERS: Destination - file handle/pointer
* *
* RETURN: None * RETURN: None
* *
@@ -344,8 +329,7 @@ AcpiOsWritable (
*****************************************************************************/ *****************************************************************************/
void void
AcpiOsRedirectOutput ( AcpiOsRedirectOutput(void *Destination)
void *Destination)
{ {
AcpiGbl_OutputFile = Destination; AcpiGbl_OutputFile = Destination;
} }
@@ -364,12 +348,9 @@ AcpiOsRedirectOutput (
*****************************************************************************/ *****************************************************************************/
void ACPI_INTERNAL_VAR_XFACE void ACPI_INTERNAL_VAR_XFACE
AcpiOsPrintf ( AcpiOsPrintf(const char *Fmt, ...)
const char *Fmt,
...)
{ {
va_list Args; va_list Args;
va_start(Args, Fmt); va_start(Args, Fmt);
AcpiOsVprintf(Fmt, Args); AcpiOsVprintf(Fmt, Args);
va_end(Args); va_end(Args);
@@ -390,38 +371,26 @@ AcpiOsPrintf (
*****************************************************************************/ *****************************************************************************/
void void
AcpiOsVprintf ( AcpiOsVprintf(const char *Fmt, va_list Args)
const char *Fmt,
va_list Args)
{ {
#ifndef _KERNEL_MODE #ifndef _KERNEL_MODE
INT32 Count = 0; INT32 Count = 0;
UINT8 Flags; UINT8 Flags;
Flags = AcpiGbl_DbOutputFlags; Flags = AcpiGbl_DbOutputFlags;
if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT) if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
{
/* Output is directable to either a file (if open) or the console */ /* Output is directable to either a file (if open) or the console */
if (AcpiGbl_DebugFile) {
if (AcpiGbl_DebugFile)
{
/* Output file is open, send the output there */ /* Output file is open, send the output there */
Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args); Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args);
} } else {
else
{
/* No redirection, send output to console (once only!) */ /* No redirection, send output to console (once only!) */
Flags |= ACPI_DB_CONSOLE_OUTPUT; Flags |= ACPI_DB_CONSOLE_OUTPUT;
} }
} }
if (Flags & ACPI_DB_CONSOLE_OUTPUT) if (Flags & ACPI_DB_CONSOLE_OUTPUT)
{
Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args); Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args);
}
#else #else
static char outputBuffer[1024]; static char outputBuffer[1024];
@@ -445,33 +414,27 @@ AcpiOsVprintf (
*****************************************************************************/ *****************************************************************************/
UINT32 UINT32
AcpiOsGetLine ( AcpiOsGetLine(char *Buffer)
char *Buffer)
{ {
UINT32 i = 0; UINT32 i = 0;
#ifndef _KERNEL_MODE #ifndef _KERNEL_MODE
UINT8 Temp; UINT8 Temp;
for (i = 0; ; i++) for (i = 0; ; i++) {
{
scanf("%1c", &Temp); scanf("%1c", &Temp);
if (!Temp || Temp == '\n') if (!Temp || Temp == '\n')
{
break; break;
}
Buffer[i] = Temp; Buffer[i] = Temp;
} }
#endif
/* Null terminate the buffer */ /* Null terminate the buffer */
Buffer[i] = 0; Buffer[i] = 0;
/* Return the number of bytes in the string */ /* Return the number of bytes in the string */
#endif return i;
return (i);
} }
/****************************************************************************** /******************************************************************************
@@ -488,32 +451,22 @@ AcpiOsGetLine (
* *
*****************************************************************************/ *****************************************************************************/
#define ROUNDUP(size, blocksize) (((size) + (blocksize) - 1) & ~((blocksize) - 1))
void * void *
AcpiOsMapMemory ( AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS where, ACPI_SIZE length)
ACPI_PHYSICAL_ADDRESS where,
ACPI_SIZE length)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
uint32 page_offset = ACPI_TO_INTEGER(where) % B_PAGE_SIZE;
void *map_base = ACPI_ADD_PTR(void,where,0L - page_offset);
area_id area;
void *there; void *there;
area_id area = map_physical_memory("acpi_physical_mem_area", (void *)where,
area = map_physical_memory("acpi_physical_mem_area", map_base, length, B_ANY_KERNEL_ADDRESS, 0, &there);
ROUNDUP(length + page_offset,B_PAGE_SIZE),B_ANY_KERNEL_ADDRESS, 0,
&there);
if (area < 0) { if (area < 0) {
dprintf("ACPI: cannot map memory at %p, length %d\n", map_base, length); dprintf("ACPI: cannot map memory at 0x%08x, length %d\n", where, length);
return NULL; return NULL;
} }
there += page_offset;
return there; return there;
#endif #else
return NULL; return NULL;
#endif
} }
@@ -532,12 +485,9 @@ AcpiOsMapMemory (
*****************************************************************************/ *****************************************************************************/
void void
AcpiOsUnmapMemory ( AcpiOsUnmapMemory(void *where, ACPI_SIZE length)
void *where,
ACPI_SIZE length)
{ {
delete_area(area_for(where)); delete_area(area_for(where));
return;
} }
@@ -554,10 +504,9 @@ AcpiOsUnmapMemory (
*****************************************************************************/ *****************************************************************************/
void * void *
AcpiOsAllocate ( AcpiOsAllocate(ACPI_SIZE size)
ACPI_SIZE size)
{ {
return (void *)malloc((size_t)size); return malloc((size_t)size);
} }
@@ -574,8 +523,7 @@ AcpiOsAllocate (
*****************************************************************************/ *****************************************************************************/
void void
AcpiOsFree ( AcpiOsFree(void *mem)
void *mem)
{ {
free(mem); free(mem);
} }
@@ -595,12 +543,12 @@ AcpiOsFree (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsCreateSemaphore ( AcpiOsCreateSemaphore(UINT32 MaxUnits, UINT32 InitialUnits,
UINT32 MaxUnits,
UINT32 InitialUnits,
ACPI_HANDLE *OutHandle) ACPI_HANDLE *OutHandle)
{ {
*OutHandle = (ACPI_HANDLE)create_sem(InitialUnits, "acpi_sem"); *OutHandle = (ACPI_HANDLE)create_sem(InitialUnits, "acpi_sem");
if (*OutHandle < B_OK)
return AE_ERROR;
return AE_OK; return AE_OK;
} }
@@ -617,8 +565,7 @@ AcpiOsCreateSemaphore (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsDeleteSemaphore ( AcpiOsDeleteSemaphore(ACPI_HANDLE Handle)
ACPI_HANDLE Handle)
{ {
delete_sem((sem_id)Handle); delete_sem((sem_id)Handle);
return AE_OK; return AE_OK;
@@ -631,7 +578,7 @@ AcpiOsDeleteSemaphore (
* *
* PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore * PARAMETERS: Handle - Handle returned by AcpiOsCreateSemaphore
* Units - How many units to wait for * Units - How many units to wait for
* Timeout - How long to wait * Timeout - How long to wait (in milliseconds)
* *
* RETURN: Status * RETURN: Status
* *
@@ -640,10 +587,7 @@ AcpiOsDeleteSemaphore (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsWaitSemaphore ( AcpiOsWaitSemaphore(ACPI_HANDLE Handle, UINT32 Units, UINT16 Timeout)
ACPI_HANDLE Handle,
UINT32 Units,
UINT16 Timeout)
{ {
if (Timeout != ACPI_WAIT_FOREVER) { if (Timeout != ACPI_WAIT_FOREVER) {
switch (acquire_sem_etc((sem_id)Handle, Units, B_RELATIVE_TIMEOUT, switch (acquire_sem_etc((sem_id)Handle, Units, B_RELATIVE_TIMEOUT,
@@ -678,9 +622,7 @@ AcpiOsWaitSemaphore (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsSignalSemaphore ( AcpiOsSignalSemaphore(ACPI_HANDLE Handle, UINT32 Units)
ACPI_HANDLE Handle,
UINT32 Units)
{ {
release_sem_etc((sem_id)Handle, Units, 0); release_sem_etc((sem_id)Handle, Units, 0);
return AE_OK; return AE_OK;
@@ -688,8 +630,7 @@ AcpiOsSignalSemaphore (
ACPI_STATUS ACPI_STATUS
AcpiOsCreateLock ( AcpiOsCreateLock(ACPI_HANDLE *OutHandle)
ACPI_HANDLE *OutHandle)
{ {
*OutHandle = (ACPI_HANDLE)malloc(sizeof(spinlock)); *OutHandle = (ACPI_HANDLE)malloc(sizeof(spinlock));
if (OutHandle == NULL) if (OutHandle == NULL)
@@ -700,16 +641,14 @@ AcpiOsCreateLock (
} }
void void
AcpiOsDeleteLock ( AcpiOsDeleteLock(ACPI_HANDLE Handle)
ACPI_HANDLE Handle)
{ {
free(Handle); free(Handle);
} }
ACPI_CPU_FLAGS ACPI_CPU_FLAGS
AcpiOsAcquireLock ( AcpiOsAcquireLock(ACPI_HANDLE Handle)
ACPI_HANDLE Handle)
{ {
cpu_status cpu = disable_interrupts(); cpu_status cpu = disable_interrupts();
acquire_spinlock((spinlock *)Handle); acquire_spinlock((spinlock *)Handle);
@@ -718,9 +657,7 @@ AcpiOsAcquireLock (
void void
AcpiOsReleaseLock ( AcpiOsReleaseLock(ACPI_HANDLE Handle, ACPI_CPU_FLAGS Flags)
ACPI_HANDLE Handle,
ACPI_CPU_FLAGS Flags)
{ {
release_spinlock((spinlock *)Handle); release_spinlock((spinlock *)Handle);
restore_interrupts((cpu_status)Flags); restore_interrupts((cpu_status)Flags);
@@ -743,19 +680,18 @@ AcpiOsReleaseLock (
*****************************************************************************/ *****************************************************************************/
UINT32 UINT32
AcpiOsInstallInterruptHandler ( AcpiOsInstallInterruptHandler(UINT32 InterruptNumber,
UINT32 InterruptNumber, ACPI_OSD_HANDLER ServiceRoutine, void *Context)
ACPI_OSD_HANDLER ServiceRoutine,
void *Context)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
install_io_interrupt_handler(InterruptNumber, install_io_interrupt_handler(InterruptNumber,
(interrupt_handler)ServiceRoutine, Context, 0); (interrupt_handler)ServiceRoutine, Context, 0);
/* It so happens that the Haiku and ACPI-CA interrupt handler routines /* It so happens that the Haiku and ACPI-CA interrupt handler routines
return the same values with the same meanings */ return the same values with the same meanings */
#endif
return AE_OK; return AE_OK;
#else
return AE_ERROR;
#endif
} }
@@ -772,8 +708,7 @@ AcpiOsInstallInterruptHandler (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsRemoveInterruptHandler ( AcpiOsRemoveInterruptHandler(UINT32 InterruptNumber,
UINT32 InterruptNumber,
ACPI_OSD_HANDLER ServiceRoutine) ACPI_OSD_HANDLER ServiceRoutine)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
@@ -804,9 +739,7 @@ AcpiOsRemoveInterruptHandler (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsExecute ( AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function,
ACPI_EXECUTE_TYPE Type,
ACPI_OSD_EXEC_CALLBACK Function,
void *Context) void *Context)
{ {
switch (Type) { switch (Type) {
@@ -840,21 +773,12 @@ AcpiOsExecute (
#if 0 #if 0
ACPI_STATUS ACPI_STATUS
AcpiOsBreakpoint ( AcpiOsBreakpoint(char *Msg)
char *Msg)
{
/* Print the message and do an INT 3 */
if (Msg)
{ {
if (Msg != NULL)
kernel_debugger ("AcpiOsBreakpoint: %s ****\n", Msg); kernel_debugger ("AcpiOsBreakpoint: %s ****\n", Msg);
}
else else
{
kernel_debugger ("At AcpiOsBreakpoint ****\n"); kernel_debugger ("At AcpiOsBreakpoint ****\n");
}
return AE_OK; return AE_OK;
} }
@@ -873,8 +797,7 @@ AcpiOsBreakpoint (
*****************************************************************************/ *****************************************************************************/
void void
AcpiOsStall ( AcpiOsStall(UINT32 microseconds)
UINT32 microseconds)
{ {
spin(microseconds); spin(microseconds);
} }
@@ -893,8 +816,7 @@ AcpiOsStall (
*****************************************************************************/ *****************************************************************************/
void void
AcpiOsSleep ( AcpiOsSleep(ACPI_INTEGER milliseconds)
ACPI_INTEGER milliseconds)
{ {
snooze(milliseconds * 1000); /* Sleep for micro seconds */ snooze(milliseconds * 1000); /* Sleep for micro seconds */
} }
@@ -932,8 +854,7 @@ AcpiOsGetTimer (void)
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsValidateInterface ( AcpiOsValidateInterface(char *Interface)
char *Interface)
{ {
return AE_SUPPORT; return AE_SUPPORT;
} }
@@ -956,9 +877,7 @@ AcpiOsValidateInterface (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsValidateAddress ( AcpiOsValidateAddress(UINT8 SpaceId, ACPI_PHYSICAL_ADDRESS Address,
UINT8 SpaceId,
ACPI_PHYSICAL_ADDRESS Address,
ACPI_SIZE Length) ACPI_SIZE Length)
{ {
return AE_OK; return AE_OK;
@@ -981,10 +900,7 @@ AcpiOsValidateAddress (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsReadPciConfiguration ( AcpiOsReadPciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, void *Value,
ACPI_PCI_ID *PciId,
UINT32 Register,
void *Value,
UINT32 Width) UINT32 Width)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
@@ -1023,11 +939,8 @@ AcpiOsReadPciConfiguration (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsWritePciConfiguration ( AcpiOsWritePciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register,
ACPI_PCI_ID *PciId, ACPI_INTEGER Value, UINT32 Width)
UINT32 Register,
ACPI_INTEGER Value,
UINT32 Width)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
gPCIManager->write_pci_config( gPCIManager->write_pci_config(
@@ -1040,10 +953,7 @@ AcpiOsWritePciConfiguration (
/* TEMPORARY STUB FUNCTION */ /* TEMPORARY STUB FUNCTION */
void void
AcpiOsDerivePciId( AcpiOsDerivePciId(ACPI_HANDLE rhandle, ACPI_HANDLE chandle, ACPI_PCI_ID **PciId)
ACPI_HANDLE rhandle,
ACPI_HANDLE chandle,
ACPI_PCI_ID **PciId)
{ {
} }
@@ -1063,10 +973,7 @@ AcpiOsDerivePciId(
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsReadPort ( AcpiOsReadPort(ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width)
ACPI_IO_ADDRESS Address,
UINT32 *Value,
UINT32 Width)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
switch (Width) { switch (Width) {
@@ -1109,10 +1016,7 @@ AcpiOsReadPort (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsWritePort ( AcpiOsWritePort(ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width)
ACPI_IO_ADDRESS Address,
UINT32 Value,
UINT32 Width)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
switch (Width) { switch (Width) {
@@ -1155,10 +1059,7 @@ AcpiOsWritePort (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsReadMemory ( AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, UINT32 *Value, UINT32 Width)
ACPI_PHYSICAL_ADDRESS Address,
UINT32 *Value,
UINT32 Width)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
addr_t pageOffset = Address % B_PAGE_SIZE; addr_t pageOffset = Address % B_PAGE_SIZE;
@@ -1192,10 +1093,7 @@ AcpiOsReadMemory (
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsWriteMemory ( AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, UINT32 Value, UINT32 Width)
ACPI_PHYSICAL_ADDRESS Address,
UINT32 Value,
UINT32 Width)
{ {
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
addr_t pageOffset = Address % B_PAGE_SIZE; addr_t pageOffset = Address % B_PAGE_SIZE;
@@ -1235,9 +1133,7 @@ AcpiOsGetThreadId(void)
*****************************************************************************/ *****************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiOsSignal ( AcpiOsSignal(UINT32 Function, void *Info)
UINT32 Function,
void *Info)
{ {
switch (Function) { switch (Function) {
case ACPI_SIGNAL_FATAL: case ACPI_SIGNAL_FATAL: