static acpi_status acpi_dm_test_resource_conversion(struct acpi_namespace_node *node, char *name) { acpi_status status; struct acpi_buffer return_buffer; struct acpi_buffer resource_buffer; struct acpi_buffer new_aml; union acpi_object *original_aml; acpi_os_printf("Resource Conversion Comparison:\n"); new_aml.length = ACPI_ALLOCATE_LOCAL_BUFFER; return_buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; resource_buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; /* Get the original _CRS AML resource template */ status = acpi_evaluate_object(node, name, NULL, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not obtain %s: %s\n", name, acpi_format_exception(status)); return (status); } /* Get the AML resource template, converted to internal resource structs */ status = acpi_get_current_resources(node, &resource_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiGetCurrentResources failed: %s\n", acpi_format_exception(status)); goto exit1; } /* Convert internal resource list to external AML resource template */ status = acpi_rs_create_aml_resources(&resource_buffer, &new_aml); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiRsCreateAmlResources failed: %s\n", acpi_format_exception(status)); goto exit2; } /* Compare original AML to the newly created AML resource list */ original_aml = return_buffer.pointer; acpi_dm_compare_aml_resources(original_aml->buffer.pointer, (acpi_rsdesc_size) original_aml->buffer. length, new_aml.pointer, (acpi_rsdesc_size) new_aml.length); /* Cleanup and exit */ ACPI_FREE(new_aml.pointer); exit2: ACPI_FREE(resource_buffer.pointer); exit1: ACPI_FREE(return_buffer.pointer); return (status); }
static int acpi_memory_get_device_resources(struct acpi_memory_device *mem_device) { acpi_status status; struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; struct acpi_resource *resource = NULL; struct acpi_resource_address64 address64; ACPI_FUNCTION_TRACE("acpi_memory_get_device_resources"); /* Get the range from the _CRS */ status = acpi_get_current_resources(mem_device->handle, &buffer); if (ACPI_FAILURE(status)) return_VALUE(-EINVAL); resource = (struct acpi_resource *)buffer.pointer; status = acpi_resource_to_address64(resource, &address64); if (ACPI_SUCCESS(status)) { if (address64.resource_type == ACPI_MEMORY_RANGE) { /* Populate the structure */ mem_device->cache_attribute = address64.attribute.memory.cache_attribute; mem_device->read_write_attribute = address64.attribute.memory.read_write_attribute; mem_device->start_addr = address64.min_address_range; mem_device->end_addr = address64.max_address_range; } } acpi_os_free(buffer.pointer); return_VALUE(0); }
acpi_status ec_get_port_values( EC_CONTEXT *ec) { acpi_status status = AE_OK; acpi_buffer buffer; acpi_resource *resource = NULL; FUNCTION_TRACE("ec_get_port_values"); if (!ec) { return_ACPI_STATUS(AE_BAD_PARAMETER); } buffer.length = 0; buffer.pointer = NULL; status = acpi_get_current_resources(ec->acpi_handle, &buffer); if (status != AE_BUFFER_OVERFLOW) { return_ACPI_STATUS(status); } buffer.pointer = acpi_os_callocate(buffer.length); if (!buffer.pointer) { return_ACPI_STATUS(AE_NO_MEMORY); } status = acpi_get_current_resources(ec->acpi_handle, &buffer); if (ACPI_FAILURE(status)) { goto end; } resource = (acpi_resource *) buffer.pointer; ec->data_port = resource->data.io.min_base_address; resource = NEXT_RESOURCE(resource); ec->status_port = ec->command_port = resource->data.io.min_base_address; end: acpi_os_free(buffer.pointer); return_ACPI_STATUS(status); }
static acpi_status acpi_evaluate_crs( acpi_handle handle, struct acpi_resource **retbuf ) { acpi_status status; struct acpi_buffer crsbuf; u8 *path_name = acpi_path_name(handle); crsbuf.length = 0; crsbuf.pointer = NULL; status = acpi_get_current_resources (handle, &crsbuf); switch (status) { case AE_BUFFER_OVERFLOW: break; /* Found */ case AE_NOT_FOUND: dbg("acpi_pciehprm:%s _CRS not found\n", path_name); return status; default: err ("acpi_pciehprm:%s _CRS fail=0x%x\n", path_name, status); return status; } crsbuf.pointer = kmalloc (crsbuf.length, GFP_KERNEL); if (!crsbuf.pointer) { err ("acpi_pciehprm: alloc %ld bytes for %s _CRS fail\n", (ulong)crsbuf.length, path_name); return AE_NO_MEMORY; } status = acpi_get_current_resources (handle, &crsbuf); if (ACPI_FAILURE(status)) { err("acpi_pciehprm: %s _CRS fail=0x%x.\n", path_name, status); kfree(crsbuf.pointer); return status; } *retbuf = crsbuf.pointer; return status; }
static acpi_status acpi_db_device_resources(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value) { struct acpi_namespace_node *node; struct acpi_namespace_node *prt_node = NULL; struct acpi_namespace_node *crs_node = NULL; struct acpi_namespace_node *prs_node = NULL; struct acpi_namespace_node *aei_node = NULL; char *parent_path; struct acpi_buffer return_buffer; acpi_status status; node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); parent_path = acpi_ns_get_normalized_pathname(node, TRUE); if (!parent_path) { return (AE_NO_MEMORY); } /* Get handles to the resource methods for this device */ (void)acpi_get_handle(node, METHOD_NAME__PRT, ACPI_CAST_PTR(acpi_handle, &prt_node)); (void)acpi_get_handle(node, METHOD_NAME__CRS, ACPI_CAST_PTR(acpi_handle, &crs_node)); (void)acpi_get_handle(node, METHOD_NAME__PRS, ACPI_CAST_PTR(acpi_handle, &prs_node)); (void)acpi_get_handle(node, METHOD_NAME__AEI, ACPI_CAST_PTR(acpi_handle, &aei_node)); if (!prt_node && !crs_node && !prs_node && !aei_node) { goto cleanup; /* Nothing to do */ } acpi_os_printf("\nDevice: %s\n", parent_path); /* Prepare for a return object of arbitrary size */ return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; /* _PRT */ if (prt_node) { acpi_os_printf("Evaluating _PRT\n"); status = acpi_evaluate_object(prt_node, NULL, NULL, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not evaluate _PRT: %s\n", acpi_format_exception(status)); goto get_crs; } return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_get_irq_routing_table(node, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("GetIrqRoutingTable failed: %s\n", acpi_format_exception(status)); goto get_crs; } acpi_rs_dump_irq_list(ACPI_CAST_PTR(u8, acpi_gbl_db_buffer)); } /* _CRS */ get_crs: if (crs_node) { acpi_os_printf("Evaluating _CRS\n"); return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_evaluate_object(crs_node, NULL, NULL, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not evaluate _CRS: %s\n", acpi_format_exception(status)); goto get_prs; } /* This code exercises the acpi_walk_resources interface */ status = acpi_walk_resources(node, METHOD_NAME__CRS, acpi_db_resource_callback, NULL); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiWalkResources failed: %s\n", acpi_format_exception(status)); goto get_prs; } /* Get the _CRS resource list (test ALLOCATE buffer) */ return_buffer.pointer = NULL; return_buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; status = acpi_get_current_resources(node, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiGetCurrentResources failed: %s\n", acpi_format_exception(status)); goto get_prs; } /* This code exercises the acpi_walk_resource_buffer interface */ status = acpi_walk_resource_buffer(&return_buffer, acpi_db_resource_callback, NULL); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiWalkResourceBuffer failed: %s\n", acpi_format_exception(status)); goto end_crs; } /* Dump the _CRS resource list */ acpi_rs_dump_resource_list(ACPI_CAST_PTR(struct acpi_resource, return_buffer. pointer)); /* * Perform comparison of original AML to newly created AML. This * tests both the AML->Resource conversion and the Resource->AML * conversion. */ (void)acpi_dm_test_resource_conversion(node, METHOD_NAME__CRS); /* Execute _SRS with the resource list */ acpi_os_printf("Evaluating _SRS\n"); status = acpi_set_current_resources(node, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiSetCurrentResources failed: %s\n", acpi_format_exception(status)); goto end_crs; } end_crs: ACPI_FREE(return_buffer.pointer); } /* _PRS */ get_prs: if (prs_node) { acpi_os_printf("Evaluating _PRS\n"); return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_evaluate_object(prs_node, NULL, NULL, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not evaluate _PRS: %s\n", acpi_format_exception(status)); goto get_aei; } return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_get_possible_resources(node, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiGetPossibleResources failed: %s\n", acpi_format_exception(status)); goto get_aei; } acpi_rs_dump_resource_list(ACPI_CAST_PTR (struct acpi_resource, acpi_gbl_db_buffer)); } /* _AEI */ get_aei: if (aei_node) { acpi_os_printf("Evaluating _AEI\n"); return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_evaluate_object(aei_node, NULL, NULL, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not evaluate _AEI: %s\n", acpi_format_exception(status)); goto cleanup; } return_buffer.pointer = acpi_gbl_db_buffer; return_buffer.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_get_event_resources(node, &return_buffer); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiGetEventResources failed: %s\n", acpi_format_exception(status)); goto cleanup; } acpi_rs_dump_resource_list(ACPI_CAST_PTR (struct acpi_resource, acpi_gbl_db_buffer)); } cleanup: ACPI_FREE(parent_path); return (AE_OK); }
void acpi_db_display_resources ( NATIVE_CHAR *object_arg) { #ifndef _IA16 acpi_operand_object *obj_desc; acpi_status status; acpi_buffer return_obj; acpi_db_set_output_destination (DB_REDIRECTABLE_OUTPUT); /* Convert string to object pointer */ obj_desc = (acpi_operand_object *) STRTOUL (object_arg, NULL, 16); /* Prepare for a return object of arbitrary size */ return_obj.pointer = acpi_gbl_db_buffer; return_obj.length = ACPI_DEBUG_BUFFER_SIZE; /* _PRT */ acpi_os_printf ("Evaluating _PRT\n"); status = acpi_evaluate_object (obj_desc, "_PRT", NULL, &return_obj); if (ACPI_FAILURE (status)) { acpi_os_printf ("Could not obtain _PRT: %s\n", acpi_format_exception (status)); goto get_crs; } return_obj.pointer = acpi_gbl_db_buffer; return_obj.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_get_irq_routing_table (obj_desc, &return_obj); if (ACPI_FAILURE (status)) { acpi_os_printf ("Get_irq_routing_table failed: %s\n", acpi_format_exception (status)); } else { acpi_rs_dump_irq_list ((u8 *) acpi_gbl_db_buffer); } /* _CRS */ get_crs: acpi_os_printf ("Evaluating _CRS\n"); return_obj.pointer = acpi_gbl_db_buffer; return_obj.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_evaluate_object (obj_desc, "_CRS", NULL, &return_obj); if (ACPI_FAILURE (status)) { acpi_os_printf ("Could not obtain _CRS: %s\n", acpi_format_exception (status)); goto get_prs; } return_obj.pointer = acpi_gbl_db_buffer; return_obj.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_get_current_resources (obj_desc, &return_obj); if (ACPI_FAILURE (status)) { acpi_os_printf ("Acpi_get_current_resources failed: %s\n", acpi_format_exception (status)); } else { acpi_rs_dump_resource_list ((acpi_resource *) acpi_gbl_db_buffer); } /* _PRS */ get_prs: acpi_os_printf ("Evaluating _PRS\n"); return_obj.pointer = acpi_gbl_db_buffer; return_obj.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_evaluate_object (obj_desc, "_PRS", NULL, &return_obj); if (ACPI_FAILURE (status)) { acpi_os_printf ("Could not obtain _PRS: %s\n", acpi_format_exception (status)); goto cleanup; } return_obj.pointer = acpi_gbl_db_buffer; return_obj.length = ACPI_DEBUG_BUFFER_SIZE; status = acpi_get_possible_resources (obj_desc, &return_obj); if (ACPI_FAILURE (status)) { acpi_os_printf ("Acpi_get_possible_resources failed: %s\n", acpi_format_exception (status)); } else { acpi_rs_dump_resource_list ((acpi_resource *) acpi_gbl_db_buffer); } cleanup: acpi_db_set_output_destination (DB_CONSOLE_OUTPUT); return; #endif }