/*
* This function changes the size of a block of memory that was previously allocated with malloc().
*/
void * GMM001_realloc (uint32_t size, void * MemPtr)
{
void * MemPtr1 = NULL;
FUNCTION_ENTRY(GID_GMM001, (uint32_t)GMM001_FUNCTION_ENTRY);
/*<<<DD_GMM001_API_3_1>>>*/
if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank1_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank1_Start + LENGTH1)))
{
MemPtr1 = LMM001_realloc(&GMM001_handle0, MemPtr, size);
}
/*<<<DD_GMM001_API_3_2>>>*/
else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank2_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank2_Start + LENGTH2)))
{
MemPtr1 = LMM001_realloc(&GMM001_handle1, MemPtr, size);
}
/*<<<DD_GMM001_API_3_3>>>*/
else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank3_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank3_Start + LENGTH3)))
{
MemPtr1 = LMM001_realloc(&GMM001_handle2, MemPtr, size);
}
FUNCTION_EXIT(GID_GMM001, (uint32_t)GMM001_FUNCTION_EXIT);
return MemPtr1;
}
u32
acpi_ns_get_pathname_length (
acpi_namespace_node *node)
{
u32 size;
acpi_namespace_node *next_node;
FUNCTION_ENTRY ();
/*
* Compute length of pathname as 5 * number of name segments.
* Go back up the parent tree to the root
*/
for (size = 0, next_node = node;
acpi_ns_get_parent_object (next_node);
next_node = acpi_ns_get_parent_object (next_node)) {
size += PATH_SEGMENT_LENGTH;
}
/* Special case for size still 0 - no parent for "special" nodes */
if (!size) {
size = PATH_SEGMENT_LENGTH;
}
return (size + 1);
}
acpi_namespace_node *
acpi_ns_map_handle_to_node (
acpi_handle handle)
{
FUNCTION_ENTRY ();
/*
* Simple implementation for now;
* TBD: [Future] Real integer handles allow for more verification
* and keep all pointers within this subsystem!
*/
if (!handle) {
return (NULL);
}
if (handle == ACPI_ROOT_OBJECT) {
return (acpi_gbl_root_node);
}
/* We can at least attempt to verify the handle */
if (!VALID_DESCRIPTOR_TYPE (handle, ACPI_DESC_TYPE_NAMED)) {
return (NULL);
}
return ((acpi_namespace_node *) handle);
}
void
acpi_rs_dump_io (
acpi_resource_data *data)
{
acpi_resource_io *io_data = (acpi_resource_io *) data;
FUNCTION_ENTRY ();
acpi_os_printf ("Io Resource\n");
acpi_os_printf (" %d bit decode\n",
DECODE_16 == io_data->io_decode ? 16 : 10);
acpi_os_printf (" Range minimum base: %08X\n",
io_data->min_base_address);
acpi_os_printf (" Range maximum base: %08X\n",
io_data->max_base_address);
acpi_os_printf (" Alignment: %08X\n",
io_data->alignment);
acpi_os_printf (" Range Length: %08X\n",
io_data->range_length);
return;
}
void
acpi_rs_dump_fixed_memory32 (
acpi_resource_data *data)
{
acpi_resource_fixed_mem32 *fixed_memory32_data = (acpi_resource_fixed_mem32 *) data;
FUNCTION_ENTRY ();
acpi_os_printf ("32-Bit Fixed Location Memory Range Resource\n");
acpi_os_printf (" Read%s\n",
READ_WRITE_MEMORY ==
fixed_memory32_data->read_write_attribute ?
"/Write" : " Only");
acpi_os_printf (" Range base address: %08X\n",
fixed_memory32_data->range_base_address);
acpi_os_printf (" Range length: %08X\n",
fixed_memory32_data->range_length);
return;
}
GtkMngView *
gtk_mng_view_new (void)
{
FUNCTION_ENTRY();
FUNCTION_EXIT();
return GTK_MNG_VIEW (g_object_new(GTK_MNG_VIEW_TYPE, NULL));
}
UINT32
AcpiNsGetPathnameLength (
ACPI_NAMESPACE_NODE *Node)
{
UINT32 Size;
ACPI_NAMESPACE_NODE *NextNode;
FUNCTION_ENTRY ();
/*
* Compute length of pathname as 5 * number of name segments.
* Go back up the parent tree to the root
*/
for (Size = 0, NextNode = Node;
AcpiNsGetParentObject (NextNode);
NextNode = AcpiNsGetParentObject (NextNode))
{
Size += PATH_SEGMENT_LENGTH;
}
/* Special case for size still 0 - no parent for "special" nodes */
if (!Size)
{
Size = PATH_SEGMENT_LENGTH;
}
return (Size + 1);
}
void DataPointObserver::processDataPointUpdate( unsigned long pkey,
boost::shared_ptr<TA_Base_Bus::DpDynamicSyncUpdate> updateDetails )
{
//
// callback from one of the DataPoint supposedly being assigned to this observer
//
std::stringstream ss;
ss << "processDataPointUpdate: Observer ID "
<< m_observerID << "--> received an update from data point " << pkey;
FUNCTION_ENTRY (ss.str().c_str() );
// only proceed if the specified pkey matches with the pkey of the
// data point assigned to this observer
DataPoint * existingDataPoint = 0;
existingDataPoint = findExistingDataPoint ( pkey );
// if found one
if ( NULL != existingDataPoint )
{
//convet it from cpp to corba first.
TA_Base_Bus::DataPointCorbaTypes::UDynamicSyncUpdate dpUpdate;
convertDynamicSyncUpdate(*updateDetails, dpUpdate);
saveDataPointUpdateDetails ( pkey, dpUpdate );
}
// else do nothing
FUNCTION_EXIT;
}
u32
acpi_tb_get_table_count (
RSDP_DESCRIPTOR *RSDP,
acpi_table_header *RSDT)
{
u32 pointer_size;
FUNCTION_ENTRY ();
#ifndef _IA64
if (RSDP->revision < 2) {
pointer_size = sizeof (u32);
}
else
#endif
{
pointer_size = sizeof (u64);
}
/*
* Determine the number of tables pointed to by the RSDT/XSDT.
* This is defined by the ACPI Specification to be the number of
* pointers contained within the RSDT/XSDT. The size of the pointers
* is architecture-dependent.
*/
return ((RSDT->length - sizeof (acpi_table_header)) / pointer_size);
}
SQLRETURN SRVR_STMT_HDL::Prepare(const SQLValue_def *inSqlString, short inStmtType, short inHoldability,
long inQueryTimeout,bool isISUD)
{
FUNCTION_ENTRY("SRVR_STMT_HDL::Prepare",(""));
DEBUG_OUT(DEBUG_LEVEL_ENTRY,(" inSqlString='%s'",
CLI_SQL_VALUE_STR(inSqlString)));
DEBUG_OUT(DEBUG_LEVEL_ENTRY,(" inStmtType=%s, inHoldability=%d, inQueryTimeout=%ld, isISUD=%d",
CliDebugStatementType(inStmtType),
inHoldability,
inQueryTimeout,isISUD));
SQLRETURN rc;
size_t len;
this->isISUD = isISUD;
if (isReadFromModule) // Already SMD label is found
CLI_DEBUG_RETURN_SQL(SQL_SUCCESS);
// cleanup all memory allocated in the previous operations
cleanupAll();
sqlString.dataCharset = inSqlString->dataCharset;
sqlString.dataType = inSqlString->dataType;
MEMORY_ALLOC_ARRAY(sqlString.dataValue._buffer,unsigned char,inSqlString->dataValue._length+1);
sqlString.dataValue._length = inSqlString->dataValue._length+1;
strncpy((char *)sqlString.dataValue._buffer, (const char *)inSqlString->dataValue._buffer, inSqlString->dataValue._length);
sqlString.dataValue._buffer[inSqlString->dataValue._length] = '\0';
stmtType = inStmtType;
holdability = inHoldability;
CLI_DEBUG_RETURN_SQL(PREPARE(this));
}
SQLRETURN SRVR_STMT_HDL::Execute(const char *inCursorName, long totalRowCount, short inSqlStmtType,
const SQLValueList_def *inValueList,
short inSqlAsyncEnable, long inQueryTimeout,
SQLValueList_def *outValueList)
{
FUNCTION_ENTRY("SRVR_STMT_HDL::Execute",(""));
DEBUG_OUT(DEBUG_LEVEL_ENTRY,(" inCursorName=%s, totalRowCount=%ld, inSqlStmtType=%s",
DebugString(inCursorName),
totalRowCount,
CliDebugSqlStatementType(inSqlStmtType)));
DEBUG_OUT(DEBUG_LEVEL_ENTRY,(" inValueList=0x%08x",
inValueList));
DEBUG_OUT(DEBUG_LEVEL_ENTRY,(" inSqlAsyncEnable=%d, inQueryTimeout=%ld",
inSqlAsyncEnable,
inQueryTimeout));
DEBUG_OUT(DEBUG_LEVEL_ENTRY,(" outValueList=0x%08x",
outValueList));
SQLRETURN rc;
char *saveptr=NULL;
SRVR_CONNECT_HDL *pConnect = NULL;
if (dialogueId == 0) CLI_DEBUG_RETURN_SQL(SQL_ERROR);
pConnect = (SRVR_CONNECT_HDL *)dialogueId;
cleanupSQLMessage();
if (rowCount._buffer == NULL || batchRowsetSize > inputRowCnt)
{
inputRowCnt = batchRowsetSize;
if (inputRowCnt == 0)
inputRowCnt = 1;
if (rowCount._buffer != NULL)
MEMORY_DELETE(rowCount._buffer);
MEMORY_ALLOC_ARRAY(rowCount._buffer,int, inputRowCnt);
rowCount._length = 0;
}
void DatabaseFactory::delDatabase( IDatabase* pDatabase )
{
FUNCTION_ENTRY("delDatabase(IDatabase*)");
if ( NULL == pDatabase )
{
LOG(SourceInfo, DebugUtil::GenericLog, DebugUtil::DebugWarn, "Invalid input parameter that IDatabase is NULL pointer");
return;
}
bool bExist = false;
{
ThreadGuard guard( m_getDatabaseLock );
// set up iterators to step through the database map.
ThreadMap::iterator threadIter (m_databaseMap.begin());
ThreadMap::iterator threadIterEnd (m_databaseMap.end());
// step through member map
while (threadIter != threadIterEnd)
{
ConnectionMap::iterator iter (threadIter->second.begin());
ConnectionMap::iterator iterEnd (threadIter->second.end());
while (iter != iterEnd)
{
if (iter->second == pDatabase)
{
threadIter->second.erase( iter );
if ( threadIter->second.empty() )
{
m_databaseMap.erase( threadIter );
}
bExist = true;
break;
}
iter++;
}
if ( bExist )
{
break;
}
threadIter++;
}
}
if ( bExist )
{
delete pDatabase;
pDatabase = NULL;
}
else
{
TA_THROW(DatabaseException("Unable to find the IDatabase"));
}
FUNCTION_EXIT;
}
void DatabaseFactory::cleanup()
{
FUNCTION_ENTRY("cleanup");
TA_Base_Core::ThreadGuard guard( m_getDatabaseLock );
// set up iterators to step through the database map.
ThreadMap::iterator threadIter (m_databaseMap.begin());
ThreadMap::iterator threadIterEnd (m_databaseMap.end());
// step through member map
while (threadIter != threadIterEnd)
{
ConnectionMap::iterator iter (threadIter->second.begin());
ConnectionMap::iterator iterEnd (threadIter->second.end());
while (iter != iterEnd)
{
if (iter->second != NULL)
{
delete iter->second;
iter->second = NULL;
}
iter++;
}
threadIter++;
}
FUNCTION_EXIT;
}
//venu changed dialogueId and stmtId from int to long for 64 bit
JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_SQLMXStatement_cancel
(JNIEnv *jenv, jobject jobj, jstring server, jlong dialogueId, jlong stmtId)
{
FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_SQLMXStatement_cancel",("..."));
ExceptionStruct exception_;
ERROR_DESC_LIST_def sqlWarning;
odbc_SQLSvc_CancelStatement_sme_(NULL, NULL, &exception_,
dialogueId,
stmtId,
&sqlWarning);
// Ignore setting warning since the input is jclass and not jobject
switch (exception_.exception_nr)
{
case CEE_SUCCESS:
break;
case odbc_SQLSvc_CancelStatement_SQLError_exn_:
throwSQLException(jenv, &exception_.u.SQLError);
break;
case odbc_SQLSvc_CancelStatement_ParamError_exn_:
throwSQLException(jenv, PROGRAMMING_ERROR, exception_.u.ParamError.ParamDesc, "HY000");
break;
case odbc_SQLSvc_CancelStatement_SQLInvalidHandle_exn_:
throwSQLException(jenv, INVALID_HANDLE_ERROR, NULL, "HY000", exception_.u.SQLInvalidHandle.sqlcode);
break;
case odbc_SQLSvc_CancelStatement_InvalidConnection_exn_:
default:
// TFDS - This exceptions should not happen
throwSQLException(jenv, PROGRAMMING_ERROR, NULL, "HY000", exception_.exception_nr);
break;
}
FUNCTION_RETURN_VOID((NULL));
}
static void
gtk_mng_view_realize (GtkWidget * widget)
{
FUNCTION_ENTRY();
GdkWindowAttr attributes;
gint attributes_mask;
g_return_if_fail (IS_GTK_MNG_VIEW (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= GDK_EXPOSURE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, widget);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}
void
AcpiHwDisableGpe (
UINT32 GpeNumber)
{
UINT32 InByte;
UINT32 RegisterIndex;
UINT32 BitMask;
FUNCTION_ENTRY ();
/*
* Translate GPE number to index into global registers array.
*/
RegisterIndex = AcpiGbl_GpeValid[GpeNumber];
/*
* Figure out the bit offset for this GPE within the target register.
*/
BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)];
/*
* Read the current value of the register, clear the appropriate bit,
* and write out the new register value to disable the GPE.
*/
InByte = 0;
AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8);
AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr,
(InByte & ~BitMask), 8);
}
static mng_bool
mng_close_stream_callback (mng_handle mng_h)
{
FUNCTION_ENTRY();
FUNCTION_EXIT();
return MNG_TRUE;
}
void
AcpiHwClearGpe (
UINT32 GpeNumber)
{
UINT32 RegisterIndex;
UINT32 BitMask;
FUNCTION_ENTRY ();
/*
* Translate GPE number to index into global registers array.
*/
RegisterIndex = AcpiGbl_GpeValid[GpeNumber];
/*
* Figure out the bit offset for this GPE within the target register.
*/
BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)];
/*
* Write a one to the appropriate bit in the status register to
* clear this GPE.
*/
AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, BitMask, 8);
}
static mng_bool
mng_read_data_callback (mng_handle mng_h,
mng_ptr buffer,
mng_uint32 bytes_requested,
mng_uint32 * bytes_read)
{
FUNCTION_ENTRY();
*bytes_read = 0;
return MNG_FALSE;
guint available_mng_food;
GtkMngView * mng_view = GTK_MNG_VIEW (mng_get_userdata (mng_h));
available_mng_food = mng_view->bytes_to_eat - mng_view->bytes_eaten;
if (available_mng_food > 0 && mng_view->mng_food != NULL)
{
* bytes_read = (mng_uint32) MIN ((mng_uint32) available_mng_food, bytes_requested);
memcpy (buffer, mng_view->mng_food + mng_view->bytes_eaten, * bytes_read);
mng_view->bytes_eaten += * bytes_read;
FUNCTION_EXIT();
return MNG_TRUE;
}
else {
FUNCTION_EXIT();
return MNG_FALSE;
}
}
/*
* Class: org_trafodion_jdbc_t2_T2Driver
* Method: setCharsetEncodingOverride
* Signature: (I)Ljava/lang/String;
* Note: This function is a generic implementation to allow setting the
* char set override encoding for the given charset (currently only the ISO88591
* column is allowed to be overriden)
*/
JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_T2Driver_setCharsetEncodingOverride(JNIEnv *jenv, jclass jcls,
jint charset, jstring encodingOverride)
{
FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_T2Driver_setCharsetEncodingOverride",
("charset=%ld, encodingOverride=%s",charset, DebugJString(jenv,encodingOverride)));
//Added for connect/disconnect impro.
if (srvrGlobal == NULL)
MEMORY_ALLOC_PERM(srvrGlobal,SRVR_GLOBAL_Def)
for (int idx=0; idx<gJNICache.totalCharsets; idx++)
if (charset == gJNICache.charsetInfo[idx].charset)
{
const char *nEncodingOverride = JNI_GetStringUTFChars(jenv,encodingOverride, NULL);
if (strcmp(nEncodingOverride,defaultEncodingOption) == 0)
{
gJNICache.charsetInfo[idx].useDefaultEncoding = TRUE;
}
else
{
gJNICache.charsetInfo[idx].useDefaultEncoding = FALSE;
}
JNI_ReleaseStringUTFChars(jenv,encodingOverride, nEncodingOverride);
}
FUNCTION_RETURN_VOID((NULL));
}
bool ParseBAND ( char *text, const sOptionTableInfo &info, sRejectOptionRMB *option )
{
FUNCTION_ENTRY ( NULL, "ParseBAND", true );
REJECT_OPTION_E type = OPTION_UNKNOWN;
while ( isspace ( *text )) text++;
if ( strncmp ( text, "BLIND", 5 ) == 0 ) {
type = OPTION_BLIND;
text += 5;
} else if ( strncmp ( text, "SAFE", 5 ) == 0 ) {
type = OPTION_SAFE;
text += 4;
} else {
goto bad_option;
}
if ( isspace ( *text )) {
bool retVal = ParseGeneric ( text, info, option );
option->Banded = true;
option->Info = FindByType ( type );
return retVal;
}
bad_option:
ParseError ( "Invalid BAND option." );
return false;
}
/*
* Class: org_trafodion_jdbc_t2_T2Driver
* Method: checkLibraryVersion
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_T2Driver_checkLibraryVersion(JNIEnv *jenv, jclass jcls,
jstring javaVproc)
{
#ifdef NSK_PLATFORM // Linux port - ToDo txn related
int cliret = client_initialization();//by venu for TSLX
if (cliret != 1)//client init return 1 on success
{
DEBUG_OUT(DEBUG_LEVEL_TXN,("TSLX initialization failed %d", cliret));
}
DEBUG_OUT(DEBUG_LEVEL_TXN,("TSLX Initialization done"));
#endif
//Added for R3.0 Transaction issue sol. 10-100430-9906
FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_T2Driver_checkLibraryVersion",("javaVproc=%s",
DebugJString(jenv,javaVproc)));
// Set the TMLIB cleanup
setTM_enable_cleanup();
#ifdef NSK_PLATFORM // Linux port
short status = tmfInit();
DEBUG_OUT(DEBUG_LEVEL_TXN,("tmfInit() returned %d", status));
if (status != 0)
{
throwTransactionException(jenv, status);
FUNCTION_RETURN_VOID(("status(%d) is non-zero",status));
}
#endif
//End
if (javaVproc && !driverVersionChecked)
{
const char *java_vproc_str = JNI_GetStringUTFChars(jenv,javaVproc, NULL);
if (java_vproc_str)
{
if (strcmp(java_vproc_str,driverVproc)!=0)
{
printf("JDBC Library Version Error - Jar: %s Jni: %s\n",
java_vproc_str,driverVproc);
abort();
}
JNI_ReleaseStringUTFChars(jenv,javaVproc, java_vproc_str);
driverVersionChecked = true;
}
}
FUNCTION_RETURN_VOID((NULL));
}
void
acpi_rs_dump_memory32 (
acpi_resource_data *data)
{
acpi_resource_mem32 *memory32_data = (acpi_resource_mem32 *) data;
FUNCTION_ENTRY ();
acpi_os_printf ("32-Bit Memory Range Resource\n");
acpi_os_printf (" Read%s\n",
READ_WRITE_MEMORY ==
memory32_data->read_write_attribute ?
"/Write" : " only");
acpi_os_printf (" Range minimum base: %08X\n",
memory32_data->min_base_address);
acpi_os_printf (" Range maximum base: %08X\n",
memory32_data->max_base_address);
acpi_os_printf (" Alignment: %08X\n",
memory32_data->alignment);
acpi_os_printf (" Range length: %08X\n",
memory32_data->range_length);
return;
}
ACPI_DEBUG_MEM_BLOCK *
AcpiUtSearchAllocList (
UINT32 ListId,
void *Address)
{
ACPI_DEBUG_MEM_BLOCK *Element;
FUNCTION_ENTRY ();
if (ListId > ACPI_MEM_LIST_MAX)
{
return (NULL);
}
Element = AcpiGbl_MemoryLists[ListId].ListHead;
/* Search for the address. */
while (Element)
{
if (Element == Address)
{
return (Element);
}
Element = Element->Next;
}
return (NULL);
}
void
acpi_rs_dump_irq (
acpi_resource_data *data)
{
acpi_resource_irq *irq_data = (acpi_resource_irq *) data;
u8 index = 0;
FUNCTION_ENTRY ();
acpi_os_printf ("IRQ Resource\n");
acpi_os_printf (" %s Triggered\n",
LEVEL_SENSITIVE == irq_data->edge_level ? "Level" : "Edge");
acpi_os_printf (" Active %s\n",
ACTIVE_LOW == irq_data->active_high_low ? "Low" : "High");
acpi_os_printf (" %s\n",
SHARED == irq_data->shared_exclusive ? "Shared" : "Exclusive");
acpi_os_printf (" %X Interrupts ( ", irq_data->number_of_interrupts);
for (index = 0; index < irq_data->number_of_interrupts; index++) {
acpi_os_printf ("%X ", irq_data->interrupts[index]);
}
acpi_os_printf (")\n");
return;
}
static mng_ptr
mng_malloc_callback (mng_size_t how_many)
{
FUNCTION_ENTRY();
FUNCTION_EXIT();
return (mng_ptr) g_new0 (gchar, how_many);
}
CCFDRequestHelper::~CCFDRequestHelper()
{
FUNCTION_ENTRY("~CDataBuffer");
FUNCTION_EXIT;
}
static gboolean
gtk_mng_view_expose (GtkWidget * widget, GdkEventExpose * event)
{
FUNCTION_ENTRY();
g_return_val_if_fail (IS_GTK_MNG_VIEW (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (GTK_WIDGET_REALIZED (widget))
{
GdkRectangle dummy;
GdkRectangle rectangle;
GtkMngView * mng_view;
mng_view = GTK_MNG_VIEW (widget);
dummy.x = dummy.y = 0;
dummy.width = mng_view->width;
dummy.height = mng_view->height;
if (gdk_rectangle_intersect (&dummy, &event->area, &rectangle))
gtk_mng_view_paint (mng_view, &rectangle);
mng_display_resume(mng_view->MNG_handle);
}
FUNCTION_EXIT();
return FALSE;
}
acpi_namespace_node *
acpi_ns_get_parent_object (
acpi_namespace_node *node)
{
FUNCTION_ENTRY ();
if (!node) {
return (NULL);
}
/*
* Walk to the end of this peer list.
* The last entry is marked with a flag and the peer
* pointer is really a pointer back to the parent.
* This saves putting a parent back pointer in each and
* every named object!
*/
while (!(node->flags & ANOBJ_END_OF_PEER_LIST)) {
node = node->peer;
}
return (node->peer);
}
void
acpi_hw_enable_gpe_for_wakeup (
u32 gpe_number)
{
u32 register_index;
u32 bit_mask;
FUNCTION_ENTRY ();
/*
* Translate GPE number to index into global registers array.
*/
register_index = acpi_gbl_gpe_valid[gpe_number];
/*
* Figure out the bit offset for this GPE within the target register.
*/
bit_mask = acpi_gbl_decode_to8bit [MOD_8 (gpe_number)];
/*
* Set the bit so we will not disable this when sleeping
*/
acpi_gbl_gpe_registers[register_index].wake_enable |= bit_mask;
}