/**************************************************************************** * * Module Name: bmpower.c - Driver for ACPI Power Resource 'devices' * $Revision: 1.1.1.1 $ * ****************************************************************************/ /* * Copyright (C) 2000, 2001 Andrew Grover * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* * TBD: 1. Sequencing of power resource list transitions. * 2. Global serialization of power resource transtions (see ACPI * spec section 7.1.2/7.1.3). * 3. Better error handling. */ #include #include "bm.h" #include "bmpower.h" #define _COMPONENT ACPI_BUS MODULE_NAME ("bmpower") /**************************************************************************** * Function Prototypes ****************************************************************************/ acpi_status bm_pr_notify ( BM_NOTIFY notify_type, BM_HANDLE device_handle, void **context); acpi_status bm_pr_request ( BM_REQUEST *request, void *context); /**************************************************************************** * Internal Functions ****************************************************************************/ /**************************************************************************** * * FUNCTION: bm_pr_print * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_print ( BM_POWER_RESOURCE *pr) { acpi_buffer buffer; PROC_NAME("bm_pr_print"); if (!pr) { return(AE_BAD_PARAMETER); } buffer.length = 256; buffer.pointer = acpi_os_callocate(buffer.length); if (!buffer.pointer) { return(AE_NO_MEMORY); } acpi_get_name(pr->acpi_handle, ACPI_FULL_PATHNAME, &buffer); acpi_os_printf("Power Resource: found\n"); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------\n")); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| Power_resource[%02x]:[%p] %s\n", pr->device_handle, pr->acpi_handle, (char*)buffer.pointer)); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| system_level[S%d] resource_order[%d]\n", pr->system_level, pr->resource_order)); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| state[D%d] reference_count[%d]\n", pr->state, pr->reference_count)); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------\n")); acpi_os_free(buffer.pointer); return(AE_OK); } /**************************************************************************** * * FUNCTION: bm_pr_get_state * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_get_state ( BM_POWER_RESOURCE *pr) { acpi_status status = AE_OK; BM_DEVICE_STATUS device_status = BM_STATUS_UNKNOWN; FUNCTION_TRACE("bm_pr_get_state"); if (!pr) { return_ACPI_STATUS(AE_BAD_PARAMETER); } pr->state = ACPI_STATE_UNKNOWN; /* * Evaluate _STA: * -------------- * Evalute _STA to determine whether the power resource is ON or OFF. * Note that if the power resource isn't present we'll get AE_OK but * an unknown status. */ status = bm_get_device_status(pr->device_handle, &device_status); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Error reading status for power resource [%02x].\n", pr->device_handle)); return_ACPI_STATUS(status); } /* * Mask off all bits but the first as some systems return non-standard * values (e.g. 0x51). */ switch (device_status & 0x01) { case 0: ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Power resource [%02x] is OFF.\n", pr->device_handle)); pr->state = ACPI_STATE_D3; break; case 1: ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Power resource [%02x] is ON.\n", pr->device_handle)); pr->state = ACPI_STATE_D0; break; } return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_set_state * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_set_state ( BM_POWER_RESOURCE *pr, BM_POWER_STATE target_state) { acpi_status status = AE_OK; FUNCTION_TRACE("bm_pr_set_state"); if (!pr) { return_ACPI_STATUS(AE_BAD_PARAMETER); } status = bm_pr_get_state(pr); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } if (target_state == pr->state) { ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Power resource [%02x] already at target power state [D%d].\n", pr->device_handle, pr->state)); return_ACPI_STATUS(AE_OK); } switch (target_state) { case ACPI_STATE_D0: ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Turning power resource [%02x] ON.\n", pr->device_handle)); status = bm_evaluate_object(pr->acpi_handle, "_ON", NULL, NULL); break; case ACPI_STATE_D3: ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Turning power resource [%02x] OFF.\n", pr->device_handle)); status = bm_evaluate_object(pr->acpi_handle, "_OFF", NULL, NULL); break; default: status = AE_BAD_PARAMETER; break; } status = bm_pr_get_state(pr); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_list_get_state * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_list_get_state ( BM_HANDLE_LIST *pr_list, BM_POWER_STATE *power_state) { acpi_status status = AE_OK; BM_POWER_RESOURCE *pr = NULL; u32 i = 0; FUNCTION_TRACE("bm_pr_list_get_state"); if (!pr_list || !power_state) { return_ACPI_STATUS(AE_BAD_PARAMETER); } if (pr_list->count < 1) { pr->state = ACPI_STATE_UNKNOWN; return_ACPI_STATUS(AE_ERROR); } (*power_state) = ACPI_STATE_D0; /* * Calculate Current power_state: * ----------------------------- * The current state of a list of power resources is ON if all * power resources are currently in the ON state. In other words, * if any power resource in the list is OFF then the collection * isn't fully ON. */ for (i = 0; i < pr_list->count; i++) { status = bm_get_device_context(pr_list->handles[i], (BM_DRIVER_CONTEXT*)(&pr)); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Invalid reference to power resource [%02x].\n", pr_list->handles[i])); (*power_state) = ACPI_STATE_UNKNOWN; break; } status = bm_pr_get_state(pr); if (ACPI_FAILURE(status)) { (*power_state) = ACPI_STATE_UNKNOWN; break; } if (pr->state != ACPI_STATE_D0) { (*power_state) = pr->state; break; } } return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_list_transition * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_list_transition ( BM_HANDLE_LIST *current_list, BM_HANDLE_LIST *target_list) { acpi_status status = AE_OK; BM_POWER_RESOURCE *pr = NULL; u32 i = 0; FUNCTION_TRACE("bm_pr_list_transition"); if (!current_list || !target_list) { return_ACPI_STATUS(AE_BAD_PARAMETER); } /* * Reference Target: * ----------------- * Reference all resources for the target power state first (so * the device doesn't get turned off while transitioning). Power * resources that aren't on (new reference count of 1) are turned on. */ for (i = 0; i < target_list->count; i++) { status = bm_get_device_context(target_list->handles[i], (BM_DRIVER_CONTEXT*)(&pr)); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Invalid reference to power resource [%02x].\n", target_list->handles[i])); continue; } if (++pr->reference_count == 1) { /* TBD: Need ordering based upon resource_order */ status = bm_pr_set_state(pr, ACPI_STATE_D0); if (ACPI_FAILURE(status)) { /* TBD: How do we handle this? */ ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Unable to change power state for power resource [%02x].\n", target_list->handles[i])); } } } /* * Dereference Current: * -------------------- * Dereference all resources for the current power state. Power * resources no longer referenced (new reference count of 0) are * turned off. */ for (i = 0; i < current_list->count; i++) { status = bm_get_device_context(current_list->handles[i], (BM_DRIVER_CONTEXT*)(&pr)); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "Invalid reference to power resource [%02x].\n", target_list->handles[i])); continue; } if (--pr->reference_count == 0) { /* TBD: Need ordering based upon resource_order */ status = bm_pr_set_state(pr, ACPI_STATE_D3); if (ACPI_FAILURE(status)) { /* TBD: How do we handle this? */ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unable to change power state for power resource [%02x].\n", current_list->handles[i])); } } } return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_add_device * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_add_device ( BM_HANDLE device_handle, void **context) { acpi_status status = AE_OK; BM_POWER_RESOURCE *pr = NULL; BM_DEVICE *device = NULL; acpi_buffer buffer; acpi_object acpi_object; FUNCTION_TRACE("bm_pr_add_device"); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Adding power resource [%02x].\n", device_handle)); if (!context || *context) { return_ACPI_STATUS(AE_BAD_PARAMETER); } buffer.length = sizeof(acpi_object); buffer.pointer = &acpi_object; /* * Get information on this device. */ status = bm_get_device_info(device_handle, &device); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* * Allocate a new BM_POWER_RESOURCE structure. */ pr = acpi_os_callocate(sizeof(BM_POWER_RESOURCE)); if (!pr) { return_ACPI_STATUS(AE_NO_MEMORY); } pr->device_handle = device->handle; pr->acpi_handle = device->acpi_handle; /* * Get information on this power resource. */ status = acpi_evaluate_object(pr->acpi_handle, NULL, NULL, &buffer); if (ACPI_FAILURE(status)) { goto end; } pr->system_level = acpi_object.power_resource.system_level; pr->resource_order = acpi_object.power_resource.resource_order; pr->state = ACPI_STATE_UNKNOWN; pr->reference_count = 0; /* * Get the power resource's current state (ON|OFF). */ status = bm_pr_get_state(pr); end: if (ACPI_FAILURE(status)) { acpi_os_free(pr); } else { *context = pr; bm_pr_print(pr); } return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_remove_device * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_remove_device ( void **context) { acpi_status status = AE_OK; BM_POWER_RESOURCE *pr = NULL; FUNCTION_TRACE("bm_pr_remove_device"); if (!context || !*context) { return_ACPI_STATUS(AE_BAD_PARAMETER); } pr = (BM_POWER_RESOURCE*)*context; ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing power resource [%02x].\n", pr->device_handle)); acpi_os_free(pr); return_ACPI_STATUS(status); } /**************************************************************************** * External Functions ****************************************************************************/ /**************************************************************************** * * FUNCTION: bm_pr_initialize * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_initialize (void) { acpi_status status = AE_OK; BM_DEVICE_ID criteria; BM_DRIVER driver; FUNCTION_TRACE("bm_pr_initialize"); MEMSET(&criteria, 0, sizeof(BM_DEVICE_ID)); MEMSET(&driver, 0, sizeof(BM_DRIVER)); criteria.type = BM_TYPE_POWER_RESOURCE; driver.notify = &bm_pr_notify; driver.request = &bm_pr_request; status = bm_register_driver(&criteria, &driver); return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_terminate * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_terminate (void) { acpi_status status = AE_OK; BM_DEVICE_ID criteria; BM_DRIVER driver; FUNCTION_TRACE("bm_pr_terminate"); MEMSET(&criteria, 0, sizeof(BM_DEVICE_ID)); MEMSET(&driver, 0, sizeof(BM_DRIVER)); criteria.type = BM_TYPE_POWER_RESOURCE; driver.notify = &bm_pr_notify; driver.request = &bm_pr_request; status = bm_unregister_driver(&criteria, &driver); return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_notify * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_notify ( BM_NOTIFY notify_type, BM_HANDLE device_handle, void **context) { acpi_status status = AE_OK; FUNCTION_TRACE("bm_pr_notify"); switch (notify_type) { case BM_NOTIFY_DEVICE_ADDED: status = bm_pr_add_device(device_handle, context); break; case BM_NOTIFY_DEVICE_REMOVED: status = bm_pr_remove_device(context); break; default: status = AE_SUPPORT; break; } return_ACPI_STATUS(status); } /**************************************************************************** * * FUNCTION: bm_pr_request * * PARAMETERS: * * RETURN: * * DESCRIPTION: * ****************************************************************************/ acpi_status bm_pr_request ( BM_REQUEST *request, void *context) { acpi_status status = AE_OK; BM_POWER_RESOURCE *pr = NULL; FUNCTION_TRACE("bm_pr_request"); /* * Must have a valid request structure and context. */ if (!request || !context) { return_ACPI_STATUS(AE_BAD_PARAMETER); } /* * context contains information specific to this power resource. */ pr = (BM_POWER_RESOURCE*)context; /* * Handle request: * --------------- */ switch (request->command) { default: status = AE_SUPPORT; break; } request->status = status; return_ACPI_STATUS(status); }