acpi_status ec_remove_device( void **context) { acpi_status status = AE_OK; EC_CONTEXT *ec = NULL; FUNCTION_TRACE("ec_remove_device"); if (!context || !*context) { return_ACPI_STATUS(AE_BAD_PARAMETER); } ec = (EC_CONTEXT*)*context; ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing EC device [%02x].\n", ec->device_handle)); ec_remove_space_handler(ec); ec_remove_gpe_handler(ec); if (ec->mutex) { acpi_os_delete_semaphore(ec->mutex); } acpi_os_free(ec); *context = NULL; return_ACPI_STATUS(status); }
static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id) { acpi_status status; ACPI_FUNCTION_TRACE_U32("ut_delete_mutex", mutex_id); if (mutex_id > MAX_MUTEX) { return_ACPI_STATUS(AE_BAD_PARAMETER); } status = acpi_os_delete_semaphore(acpi_gbl_mutex_info[mutex_id].mutex); acpi_gbl_mutex_info[mutex_id].mutex = NULL; acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED; return_ACPI_STATUS(status); }
ACPI_STATUS acpi_cm_delete_mutex ( ACPI_MUTEX_HANDLE mutex_id) { ACPI_STATUS status; if (mutex_id > MAX_MTX) { return (AE_BAD_PARAMETER); } status = acpi_os_delete_semaphore (acpi_gbl_acpi_mutex_info[mutex_id].mutex); acpi_gbl_acpi_mutex_info[mutex_id].mutex = NULL; acpi_gbl_acpi_mutex_info[mutex_id].locked = FALSE; return (status); }
acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc) { acpi_status status = AE_OK; acpi_semaphore temp_semaphore; ACPI_FUNCTION_ENTRY(); /* * We are going to simply delete the existing semaphore and * create a new one! */ status = acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, &temp_semaphore); if (ACPI_SUCCESS(status)) { (void)acpi_os_delete_semaphore(obj_desc->event.os_semaphore); obj_desc->event.os_semaphore = temp_semaphore; } return (status); }
acpi_status acpi_ut_delete_mutex ( ACPI_MUTEX_HANDLE mutex_id) { acpi_status status; FUNCTION_TRACE_U32 ("Ut_delete_mutex", mutex_id); if (mutex_id > MAX_MTX) { return_ACPI_STATUS (AE_BAD_PARAMETER); } status = acpi_os_delete_semaphore (acpi_gbl_acpi_mutex_info[mutex_id].mutex); acpi_gbl_acpi_mutex_info[mutex_id].mutex = NULL; acpi_gbl_acpi_mutex_info[mutex_id].owner_id = ACPI_MUTEX_NOT_ACQUIRED; return_ACPI_STATUS (status); }
void acpi_os_delete_lock(acpi_spinlock handle) { acpi_os_delete_semaphore(handle); }
static void acpi_ut_delete_internal_obj(union acpi_operand_object *object) { void *obj_pointer = NULL; union acpi_operand_object *handler_desc; union acpi_operand_object *second_desc; union acpi_operand_object *next_desc; ACPI_FUNCTION_TRACE_PTR(ut_delete_internal_obj, object); if (!object) { return_VOID; } /* * Must delete or free any pointers within the object that are not * actual ACPI objects (for example, a raw buffer pointer). */ switch (ACPI_GET_OBJECT_TYPE(object)) { case ACPI_TYPE_STRING: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "**** String %p, ptr %p\n", object, object->string.pointer)); /* Free the actual string buffer */ if (!(object->common.flags & AOPOBJ_STATIC_POINTER)) { /* But only if it is NOT a pointer into an ACPI table */ obj_pointer = object->string.pointer; } break; case ACPI_TYPE_BUFFER: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "**** Buffer %p, ptr %p\n", object, object->buffer.pointer)); /* Free the actual buffer */ if (!(object->common.flags & AOPOBJ_STATIC_POINTER)) { /* But only if it is NOT a pointer into an ACPI table */ obj_pointer = object->buffer.pointer; } break; case ACPI_TYPE_PACKAGE: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, " **** Package of count %X\n", object->package.count)); /* * Elements of the package are not handled here, they are deleted * separately */ /* Free the (variable length) element pointer array */ obj_pointer = object->package.elements; break; case ACPI_TYPE_DEVICE: if (object->device.gpe_block) { (void)acpi_ev_delete_gpe_block(object->device. gpe_block); } /* Walk the handler list for this device */ handler_desc = object->device.handler; while (handler_desc) { next_desc = handler_desc->address_space.next; acpi_ut_remove_reference(handler_desc); handler_desc = next_desc; } break; case ACPI_TYPE_MUTEX: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "***** Mutex %p, OS Mutex %p\n", object, object->mutex.os_mutex)); if (object->mutex.os_mutex == acpi_gbl_global_lock_mutex) { /* Global Lock has extra semaphore */ (void) acpi_os_delete_semaphore (acpi_gbl_global_lock_semaphore); acpi_gbl_global_lock_semaphore = NULL; acpi_os_delete_mutex(object->mutex.os_mutex); acpi_gbl_global_lock_mutex = NULL; } else { acpi_ex_unlink_mutex(object); acpi_os_delete_mutex(object->mutex.os_mutex); } break; case ACPI_TYPE_EVENT: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "***** Event %p, OS Semaphore %p\n", object, object->event.os_semaphore)); (void)acpi_os_delete_semaphore(object->event.os_semaphore); object->event.os_semaphore = NULL; break; case ACPI_TYPE_METHOD: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "***** Method %p\n", object)); /* Delete the method mutex if it exists */ if (object->method.mutex) { acpi_os_delete_mutex(object->method.mutex->mutex. os_mutex); acpi_ut_delete_object_desc(object->method.mutex); object->method.mutex = NULL; } break; case ACPI_TYPE_REGION: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "***** Region %p\n", object)); second_desc = acpi_ns_get_secondary_object(object); if (second_desc) { /* * Free the region_context if and only if the handler is one of the * default handlers -- and therefore, we created the context object * locally, it was not created by an external caller. */ handler_desc = object->region.handler; if (handler_desc) { if (handler_desc->address_space.handler_flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) { /* Deactivate region and free region context */ if (handler_desc->address_space.setup) { (void)handler_desc-> address_space.setup(object, ACPI_REGION_DEACTIVATE, handler_desc-> address_space. context, &second_desc-> extra. region_context); } } acpi_ut_remove_reference(handler_desc); } /* Now we can free the Extra object */ acpi_ut_delete_object_desc(second_desc); } break; case ACPI_TYPE_BUFFER_FIELD: ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "***** Buffer Field %p\n", object)); second_desc = acpi_ns_get_secondary_object(object); if (second_desc) { acpi_ut_delete_object_desc(second_desc); } break; default: break; } /* Free any allocated memory (pointer within the object) found above */ if (obj_pointer) { ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n", obj_pointer)); ACPI_FREE(obj_pointer); } /* Now the object can be safely deleted */ ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n", object, acpi_ut_get_object_type_name(object))); acpi_ut_delete_object_desc(object); return_VOID; }
acpi_status ec_add_device( BM_HANDLE device_handle, void **context) { acpi_status status = AE_OK; BM_DEVICE *device = NULL; EC_CONTEXT *ec = NULL; u8 gpe_handler = FALSE; u8 space_handler = FALSE; FUNCTION_TRACE("ec_add_device"); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Adding EC device [%02x].\n", device_handle)); if (!context || *context) { return_ACPI_STATUS(AE_BAD_PARAMETER); } /* * Get information on this device. */ status = bm_get_device_info(device_handle, &device); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* * Allocate a new EC_CONTEXT structure. */ ec = acpi_os_callocate(sizeof(EC_CONTEXT)); if (!ec) { return_ACPI_STATUS(AE_NO_MEMORY); } ec->device_handle = device->handle; ec->acpi_handle = device->acpi_handle; /* * Get the I/O port addresses for the command/status and data ports. */ status = ec_get_port_values(ec); if (ACPI_FAILURE(status)) { goto end; } /* * See if we need to obtain the global lock for EC transactions. */ status = bm_evaluate_simple_integer(ec->acpi_handle, "_GLK", &ec->use_global_lock); if (status == AE_NOT_FOUND) { ec->use_global_lock = 0; } else if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "EC _GLK failed\n")); goto end; } /* * Install a handler for servicing this EC's GPE. */ status = ec_install_gpe_handler(ec); if (ACPI_FAILURE(status)) { goto end; } else { gpe_handler = TRUE; } /* * Install a handler for servicing this EC's address space. */ status = ec_install_space_handler(ec); if (ACPI_FAILURE(status)) { goto end; } else { space_handler = TRUE; } /* * Create a semaphore to serialize EC transactions. */ status = acpi_os_create_semaphore(1,1, &(ec->mutex)); if (ACPI_FAILURE(status)) { goto end; } /* * Context now contains information specific to this EC. Note * that we'll get this pointer back on every ec_request() and * ec_notify(). */ *context = ec; ec_print(ec); end: if (ACPI_FAILURE(status)) { if (gpe_handler) { ec_remove_gpe_handler(ec); } if (space_handler) { ec_remove_space_handler(ec); } if (ec->mutex) { acpi_os_delete_semaphore(ec->mutex); } acpi_os_free(ec); } return_ACPI_STATUS(status); }
void acpi_db_create_execution_threads ( NATIVE_CHAR *num_threads_arg, NATIVE_CHAR *num_loops_arg, NATIVE_CHAR *method_name_arg) { acpi_status status; u32 num_threads; u32 num_loops; u32 i; acpi_handle thread_gate; /* Get the arguments */ num_threads = STRTOUL (num_threads_arg, NULL, 0); num_loops = STRTOUL (num_loops_arg, NULL, 0); if (!num_threads || !num_loops) { acpi_os_printf ("Bad argument: Threads %X, Loops %X\n", num_threads, num_loops); return; } /* Create the synchronization semaphore */ status = acpi_os_create_semaphore (1, 0, &thread_gate); if (ACPI_FAILURE (status)) { acpi_os_printf ("Could not create semaphore, %s\n", acpi_format_exception (status)); return; } /* Setup the context to be passed to each thread */ acpi_gbl_db_method_info.name = method_name_arg; acpi_gbl_db_method_info.args = NULL; acpi_gbl_db_method_info.flags = 0; acpi_gbl_db_method_info.num_loops = num_loops; acpi_gbl_db_method_info.thread_gate = thread_gate; acpi_db_execute_setup (&acpi_gbl_db_method_info); /* Create the threads */ acpi_os_printf ("Creating %X threads to execute %X times each\n", num_threads, num_loops); for (i = 0; i < (num_threads); i++) { acpi_os_queue_for_execution (OSD_PRIORITY_MED, acpi_db_method_thread, &acpi_gbl_db_method_info); } /* Wait for all threads to complete */ i = num_threads; while (i) /* Brain damage for OSD implementations that only support wait of 1 unit */ { status = acpi_os_wait_semaphore (thread_gate, 1, WAIT_FOREVER); i--; } /* Cleanup and exit */ acpi_os_delete_semaphore (thread_gate); acpi_db_set_output_destination (DB_DUPLICATE_OUTPUT); acpi_os_printf ("All threads (%X) have completed\n", num_threads); acpi_db_set_output_destination (DB_CONSOLE_OUTPUT); }