cmcopy.c

winNT技术操作系统,国外开放的原代码和LIUX一样

ACPI_STATUS
acpi_cm_copy_iobject_to_eobject (
	ACPI_OPERAND_OBJECT     *internal_object,
	ACPI_BUFFER             *ret_buffer)
{
	ACPI_STATUS             status;


	if (IS_THIS_OBJECT_TYPE (internal_object, ACPI_TYPE_PACKAGE)) {
		/*
		 * Package object:  Copy all subobjects (including
		 * nested packages)
		 */
		status = acpi_cm_copy_ipackage_to_epackage (internal_object,
				  ret_buffer->pointer, &ret_buffer->length);
	}

	else {
		/*
		 * Build a simple object (no nested objects)
		 */
		status = acpi_cm_copy_isimple_to_esimple (internal_object,
				  (ACPI_OBJECT *) ret_buffer->pointer,
				  ((u8 *) ret_buffer->pointer +
				  ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT))),
				  &ret_buffer->length);
		/*
		 * build simple does not include the object size in the length
		 * so we add it in here
		 */
		ret_buffer->length += sizeof (ACPI_OBJECT);
	}

	return (status);
}


/*******************************************************************************
 *
 * FUNCTION:    Acpi_cm_copy_esimple_to_isimple
 *
 * PARAMETERS:  *External_object   - The external object to be converted
 *              *Internal_object   - Where the internal object is returned
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This function copies an external object to an internal one.
 *              NOTE: Pointers can be copied, we don't need to copy data.
 *              (The pointers have to be valid in our address space no matter
 *              what we do with them!)
 *
 ******************************************************************************/

ACPI_STATUS
acpi_cm_copy_esimple_to_isimple (
	ACPI_OBJECT             *external_object,
	ACPI_OPERAND_OBJECT     *internal_object)
{


	internal_object->common.type = (u8) external_object->type;

	switch (external_object->type) {

	case ACPI_TYPE_STRING:

		internal_object->string.length = external_object->string.length;
		internal_object->string.pointer = external_object->string.pointer;
		break;


	case ACPI_TYPE_BUFFER:

		internal_object->buffer.length = external_object->buffer.length;
		internal_object->buffer.pointer = external_object->buffer.pointer;
		break;


	case ACPI_TYPE_INTEGER:
		/*
		 * Number is included in the object itself
		 */
		internal_object->integer.value  = external_object->integer.value;
		break;


	default:
		return (AE_CTRL_RETURN_VALUE);
		break;
	}


	return (AE_OK);
}


#ifdef ACPI_FUTURE_IMPLEMENTATION

/* Code to convert packages that are parameters to control methods */

/*******************************************************************************
 *
 * FUNCTION:    Acpi_cm_copy_epackage_to_ipackage
 *
 * PARAMETERS:  *Internal_object   - Pointer to the object we are returning
 *              *Buffer         - Where the object is returned
 *              *Space_used     - Where the length of the object is returned
 *
 * RETURN:      Status          - the status of the call
 *
 * DESCRIPTION: This function is called to place a package object in a user
 *              buffer.  A package object by definition contains other objects.
 *
 *              The buffer is assumed to have sufficient space for the object.
 *              The caller must have verified the buffer length needed using the
 *              Acpi_cm_get_object_size function before calling this function.
 *
 ******************************************************************************/

static ACPI_STATUS
acpi_cm_copy_epackage_to_ipackage (
	ACPI_OPERAND_OBJECT     *internal_object,
	u8                      *buffer,
	u32                     *space_used)
{
	u8                      *free_space;
	ACPI_OBJECT             *external_object;
	u32                     length = 0;
	u32                     this_index;
	u32                     object_space = 0;
	ACPI_OPERAND_OBJECT     *this_internal_obj;
	ACPI_OBJECT             *this_external_obj;


	/*
	 * First package at head of the buffer
	 */
	external_object = (ACPI_OBJECT *)buffer;

	/*
	 * Free space begins right after the first package
	 */
	free_space = buffer + sizeof(ACPI_OBJECT);


	external_object->type              = internal_object->common.type;
	external_object->package.count     = internal_object->package.count;
	external_object->package.elements  = (ACPI_OBJECT *)free_space;


	/*
	 * Build an array of ACPI_OBJECTS in the buffer
	 * and move the free space past it
	 */

	free_space += external_object->package.count * sizeof(ACPI_OBJECT);


	/* Call Walk_package */

}

#endif /* Future implementation */


/*******************************************************************************
 *
 * FUNCTION:    Acpi_cm_copy_eobject_to_iobject
 *
 * PARAMETERS:  *Internal_object   - The external object to be converted
 *              *Buffer_ptr     - Where the internal object is returned
 *
 * RETURN:      Status          - the status of the call
 *
 * DESCRIPTION: Converts an external object to an internal object.
 *
 ******************************************************************************/

ACPI_STATUS
acpi_cm_copy_eobject_to_iobject (
	ACPI_OBJECT             *external_object,
	ACPI_OPERAND_OBJECT     *internal_object)
{
	ACPI_STATUS             status;


	if (external_object->type == ACPI_TYPE_PACKAGE) {
		/*
		 * Package objects contain other objects (which can be objects)
		 * buildpackage does it all
		 *
		 * TBD: Package conversion must be completed and tested
		 * NOTE: this code converts packages as input parameters to
		 * control methods only.  This is a very, very rare case.
		 */
/*
		Status = Acpi_cm_copy_epackage_to_ipackage(Internal_object,
				 Ret_buffer->Pointer,
				 &Ret_buffer->Length);
*/
		return (AE_NOT_IMPLEMENTED);
	}

	else {
		/*
		 * Build a simple object (no nested objects)
		 */
		status = acpi_cm_copy_esimple_to_isimple (external_object, internal_object);
		/*
		 * build simple does not include the object size in the length
		 * so we add it in here
		 */
	}

	return (status);
}


/*******************************************************************************
 *
 * FUNCTION:    Acpi_cm_copy_ielement_to_ielement
 *
 * PARAMETERS:  ACPI_PKG_CALLBACK
 *
 * RETURN:      Status          - the status of the call
 *
 * DESCRIPTION: Copy one package element to another package element
 *
 ******************************************************************************/

ACPI_STATUS
acpi_cm_copy_ielement_to_ielement (
	u8                      object_type,
	ACPI_OPERAND_OBJECT     *source_object,
	ACPI_GENERIC_STATE      *state,
	void                    *context)
{
	ACPI_STATUS             status = AE_OK;
	u32                     this_index;
	ACPI_OPERAND_OBJECT     **this_target_ptr;
	ACPI_OPERAND_OBJECT     *target_object;


	this_index    = state->pkg.index;
	this_target_ptr = (ACPI_OPERAND_OBJECT **)
			   &state->pkg.dest_object->package.elements[this_index];

	switch (object_type) {
	case 0:

		/*
		 * This is a simple object, just copy it
		 */
		target_object = acpi_cm_create_internal_object (source_object->common.type);
		if (!target_object) {
			return (AE_NO_MEMORY);
		}

		status = acpi_aml_store_object_to_object (source_object, target_object,
				  (ACPI_WALK_STATE *) context);
		if (ACPI_FAILURE (status)) {
			return (status);
		}

		*this_target_ptr = target_object;
		break;


	case 1:
		/*
		 * This object is a package - go down another nesting level
		 * Create and build the package object
		 */
		target_object = acpi_cm_create_internal_object (ACPI_TYPE_PACKAGE);
		if (!target_object) {
			/* TBD: must delete package created up to this point */

			return (AE_NO_MEMORY);
		}

		target_object->package.count = source_object->package.count;

		/*
		 * Pass the new package object back to the package walk routine
		 */
		state->pkg.this_target_obj = target_object;

		/*
		 * Store the object pointer in the parent package object
		 */
		*this_target_ptr = target_object;
		break;

	default:
		return (AE_BAD_PARAMETER);
	}


	return (status);
}


/*******************************************************************************
 *
 * FUNCTION:    Acpi_cm_copy_ipackage_to_ipackage
 *
 * PARAMETERS:  *Source_obj     - Pointer to the source package object
 *              *Dest_obj       - Where the internal object is returned
 *
 * RETURN:      Status          - the status of the call
 *
 * DESCRIPTION: This function is called to copy an internal package object
 *              into another internal package object.
 *
 ******************************************************************************/

ACPI_STATUS
acpi_cm_copy_ipackage_to_ipackage (
	ACPI_OPERAND_OBJECT     *source_obj,
	ACPI_OPERAND_OBJECT     *dest_obj,
	ACPI_WALK_STATE         *walk_state)
{
	ACPI_STATUS             status = AE_OK;


	dest_obj->common.type   = source_obj->common.type;
	dest_obj->package.count = source_obj->package.count;


	/*
	 * Create the object array and walk the source package tree
	 */

	dest_obj->package.elements = acpi_cm_callocate ((source_obj->package.count + 1) *
			 sizeof (void *));
	dest_obj->package.next_element = dest_obj->package.elements;

	if (!dest_obj->package.elements) {
		REPORT_ERROR (
			("Aml_build_copy_internal_package_object: Package allocation failure\n"));
		return (AE_NO_MEMORY);
	}


	status = acpi_cm_walk_package_tree (source_obj, dest_obj,
			 acpi_cm_copy_ielement_to_ielement, walk_state);

	return (status);
}